最短路径问题：如果从图中某一顶点(称为源点)到达另一顶点(称为终点)的路径可能不止一条，如何找到一条路径使得沿此路径上各边上的权值总和达到最小。

三种算法主要用途：

1.  边上权值非负情形的单源最短路径问题 —  Dijkstra算法 

2. 边上权值为任意值的单源最短路径问题 — Bellman和Ford算法

3. 所有顶点之间的最短路径 — Floyd算法

Dijkstra算法：贪心策略

算法思想：设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，已求出最短路径的顶点集合S和其余未确定最短路径的顶点集合V-S，按最短路径长度的递增次序依次把V-S的顶点加入S中。选择V-S中距离远点路径最短的点v’,以v’为中转点更新所有的点的最短路径

起始设置所有点距离源点v的最短路径。如果v’与v相连，那么最短路径就是<v,v’>的长度，否则就是无穷大

#include <iostream>

using namespace std;
const int MAX =99999999;
unsigned int n,e;
int arr[100][100];
int visited[100] = {0};
int dis[100];
void Dijkstra()
{
    for(int i = 1; i<n; i++)
    {
        int temp = MAX;
        int newVec = 0;
        for(int j = 1; j<n; j++)
        {
            if(visited[j]==0&&dis[j]<temp)
            {
                newVec = j;
                temp = dis[j];
            }
        }

        visited[newVec] = 1;
        for(int j = 1; j<n; j++)
        {
            if(visited[j] == 0&&arr[newVec][j]<MAX)
            {
                if(dis[j]>dis[newVec]+ arr[newVec][j])
                {
                    dis[j] = dis[newVec]+ arr[newVec][j];
                }
            }
        }

    }
}
int main()
{
    cin>>n>>e;
    if(n>0&&e>0)
    {
        for(int i=0; i<100; i++)
        {
            for(int j=0; j<100; j++)
            {
                if(i!=j)
                    arr[i][j] = MAX;
                else
                    arr[i][j] = 0;
            }
        }
        for(int i=0; i<e; i++)
        {
            int from,to,dis;
            cin>>from>>to>>dis;
            arr[from][to] = dis;
            //arr[to][from] = dis;
        }

        /*for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
                cout<<arr[i][j]<<" ";
            }
            cout<<endl<<endl;
        }*/

        for(int i = 0; i<n; i++)
        {
            dis[i] = arr[0][i];
        }

        /*for(int i = 0; i<n; i++)
        {
            cout<<distance[i]<<" ";
        }*/
        cout<<"Dijkstra 最短路："<<endl;
        visited[0] = 1;
        Dijkstra();
        for(int i = 0; i<n; i++)
        {
            cout<<dis[i]<<" ";
        }

    }
    return 0;
}
/*
5 7
0 1 10
0 3 30
0 4 100
1 2 50
2 4 10
3 2 20
3 4 60
*/

Bellman-Ford算法：持续松弛操作

什么叫松弛操作呢？在松弛一条边(u,v)的过程中，要测试是否可以通过u，对迄今找到的v的最短路径进行改进；如果可以改进的话，则更新d[v]。

bellman-ford算法是对图进行n-1次松弛操作，如果n-1次松弛操作以后还能继续进行松弛操作，那么说明原图中有负环（即圈的各边总权值为负）

为什么是n-1呢？我们可以确定的是，在一次对所有边进行松弛操作以后，我们至少可以确定一个定点的距离源点的最短路径（最坏可以考虑一条直线，中间有若干点，这种情况一次松弛只能确定一个点距离源点的最短路径。当一个点的连接的点个数超过一时，我们每次松弛确定得点个数大于1，最坏情况就是n-1次松弛确定所有点的最短路径）

那么，算法就很简单了，只有下面几行：

 for(int i = 0;i<n-1;i++)
        {
            for(int j = 0;j<e;j++)
            {

                if(distance[edge[j].to]>distance[edge[j].from]+edge[j].val)
                {
                    distance[edge[j].to] = distance[edge[j].from]+edge[j].val;
                }
            }
        }

完整代码如下：

#include <iostream>
#include <stdlib.h>
using namespace std;
const int MAX =99999999;
typedef struct Edge{
    int from,to;
    int val;
}Edge;
Edge edge[1000];
unsigned int n,e;
int dis[100];
bool Bellman()
{
    for(int i = 0;i<n-1;i++)
        {
            for(int j = 0;j<e;j++)
            {

                if(dis[edge[j].to]>dis[edge[j].from]+edge[j].val)
                {
                    dis[edge[j].to] = dis[edge[j].from]+edge[j].val;
                }
            }
        }
        bool flag = true;
        for(int k = 0 ; k < e;k++)
        {
            if(dis[edge[k].to]>dis[edge[k].from]+edge[k].val)
            {
                flag = false;
                break;
            }
        }
    return flag;
}
int main()
{

    cin>>n>>e;
    if(n>0&&e>0)
    {
        for(int i = 1;i<n;i++)
        {
            dis[i] = MAX;
        }
        dis[0] = 0;
        for(int i=0; i<e; i++)
        {
            int from,to,dis;
            cin>>from>>to>>dis;
            edge[i].from = from;
            edge[i].to = to;
            edge[i].val = dis;
            //arr[to][from] = dis;
        }

        for(int i = 0; i<e; i++)
        {
            if(edge[i].from == 0)
            {
                dis[edge[i].to] = edge[i].val;
            }
        }

        for(int i = 0; i<n; i++)
        {
            cout<<dis[i]<<" ";
        }
        cout<<"Bellman-Ford最短路："<<endl;
        bool flag = Bellman();
        if(flag)
        {
            for(int i = 0; i<n; i++)
            {
                cout<<dis[i]<<" ";
            }
        }
        else
        {
            cout<<"存在负环"<<endl;
        }


    }
    return 0;
}

/*
5 7
0 1 10
0 3 30
0 4 100
1 2 50
2 4 10
3 2 20
3 4 60

5 7
0 1 10
0 4 100
1 2 50
2 3 -2
3 0 -1
3 4 -6
4 2 -1
*/

Bellman的算法，存在一个问题就是每次都对所有的边进行进行松弛，会浪费一些时间复杂度。比如当我们还没有更新某个次序比较靠后的节点的时候，却会在第二个循环中，考虑用该节点去松弛其余节点。

比较好的改进措施是，我们使用一个队列，每次把刚刚进行松弛操作的节点加入队列中，每次从队列中取出节点去更新其他的节点这就是SPFA算法

void spfa()
{
    queue<int> myqueue;
    while(!myqueue.empty())
    {
        myqueue.pop();
    }
    myqueue.push(0);
    while(!myqueue.empty())
    {
        int v = myqueue.front();
        visited[v] = 0;
        myqueue.pop();
        for(int i = 0 ; i<n;i++)
        {
            if(dis[i]>dis[v]+arr[v][i])
            {
                dis[i] = dis[v] + arr[v][i];
                if(visited[i]!=1)
                {
                    visited[i] = 1;
                    myqueue.push(i);
                }
            }
        }
    }
}

使用上述spfa函数替代bellman函数即可

Floyd算法：计算图中每个顶点到其余所有顶点的最短路

这个算法时间复杂度为n^3。对于任意节点i,j遍历所有k,找到这样的k,使得以k为中转站的时候，i,j之间的最短路最短

一共三个for循环，算法很好记；前两个for循环用于遍历i,j后面一个for循环用于找到中转站k

核心代码：

    for(int k=0; k<n; k++)
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                if(arr[i][k]<MAX && arr[k][j]<MAX && arr[i][j]>arr[i][k]+arr[k][j])
                    arr[i][j]=arr[i][k]+arr[k][j];

算法实现：

#include <iostream>

using namespace std;
const int MAX =99999999;
unsigned int n,e;
int arr[100][100];
void floyd()
{
    for(int k=0; k<n; k++)
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                if(arr[i][k]<MAX && arr[k][j]<MAX && arr[i][j]>arr[i][k]+arr[k][j])
                    arr[i][j]=arr[i][k]+arr[k][j];
}
int main()
{
    cin>>n>>e;
    if(n>0&&e>0)
    {
        for(int i=0; i<100; i++)
        {
            for(int j=0; j<100; j++)
            {
                if(i!=j)
                    arr[i][j] = MAX;
                else
                    arr[i][j] = 0;
            }
        }
        for(int i=0; i<e; i++)
        {
            int from,to,dis;
            cin>>from>>to>>dis;
            arr[from][to] = dis;
            arr[to][from] = dis;
        }
        floyd();
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
               cout<<arr[i][j]<<" ";
            }
            cout<<endl;
        }
        return 0;
    }

}

/*
5 7
0 1 10
0 3 30
0 4 100
1 2 50
2 4 10
3 2 20
3 4 60
*/

文章中有的地方使用的是有向图表达，有的是无向图表达。望注意

P.S.文章不妥之处还望指正