最短路问题的四种算法（Bellman-ford、SPFA、Dijkstra、Floyd）

Bellman-Ford算法

Bellman-Ford算法用来计算单源最短路。该算法可以处理边权为负的情况，同时可以判断图中是否有负权环。
松弛一条边(u,v)即判断能否通过u对v的最短路径进行改进，如果可以，则更新d[v]。
松弛操作：d[v]>d[u]+w(u,v) → d[v]=d[u]+w(u,v) 。其中w(u,v)表示边(u,v)的权值。
松弛操作在没有负权环的情况下最多进行|V|-1轮。也就是说，若完成|v|-1轮松弛操作后还能进行松弛操作，那么图中有负权环。
复杂度：O(|V||E|)

struct edge{ int from, to, cost; };

edge es[MAX_E];		//边

int d[MAX_V];       //最短距离
int V, E;           //V是顶点数， E是边数

void bellman_ford(int s)
{
    fill(d, d + V, INF);
    d[s] = 0;
    while(true)
    {
        bool update = false;
        for(int i = 0; i < E; i++)
        {
            edge e = es[i];
            if(d[e.from] != INF && d[e.to] > d[e.from] + e.cost)
            {
                d[e.to] = d[e.from]+e.cost;
                update = true;
            }
        }
        if(!update) break;
    }
}

SPFA算法

SPFA是Bellman-Ford的队列优化。
Bellman-Ford算法每轮都遍历所有的边试图进行松弛操作，而实际上并不是所有的边都能够进行松弛操作。
SPFA算法通过建立一个队列来保持待优化的顶点，只有当到某个顶点的最短距离缩短后，才用连接该顶点的边对另一端点进行松弛操作。
复杂度：最坏情况O(|V||E|)

struct edge{ int to, cost; };

vector<edge> G[MAX_V];

int d[MAX_V];
bool inQue[MAX_V];

void spfa(int s)
{
    queue<int> que;
    fill(d, d + V, INF);
    d[s] = 0;
    que.push(s);
    inQue[s] = true;
    while(!que.empty())
    {
        int u = que.front(); que.pop();
        for(int i = 0; i < G[u].size(); i++)
        {
            edge e = G[u][i];
            if(d[e.to] > d[u] + e.cost)
            {
                d[e.to] = d[u] + e.cost;
                if(!inQue[e.to])
                {
                    inQue[e.to] = true;
                    que.push(e.to);
                }
            }
        }
        inQue[u] = false;
    }
}

Dijkstra算法

在Bellman-Ford算法中，如果d[u]还不是最短距离的话，那么即使对d[v]进行d[v]>d[u]+w(u,v) → d[v]=d[u]+w(u,v)的更新，d[v]也不会变成最短距离。因此Dijkstra算法做了如下修改：

1. 找到最短距离已经确定的顶点，从它出发更新相邻顶点的最短距离。
2. 此后不再需要关心1中的“最短距离已经确定的顶点”。

代码实现：

int cost[MAX_V][MAX_V];            //邻接矩阵
int d[MAX_V];					   //最短距离
bool used[MAX_V];                  //已经使用过的顶点
int V;                             //顶点数

void dijkstra(int s)
{
    fill(d, d + V, INF);
    fill(used , used + V, false);
    d[s] = 0;
    while(true)
    {
    	int v = -1;
    	//从未使用过的顶点中选一个距离最小的顶点
        for(int i = 0; i < V; i++)
            if(!used[i] && (v == -1 || d[i] < d[v])) v = i;
        if(v == -1) break;
        used[v] = true;
        for(int i = 0; i < V; i++)
            d[i] = min(d[i], d[v] + cost[v][i]);
    }
}

Dijkstra算法（优先队列优化）

每次查找距离最小的顶点的操作可以用堆来实现。把每个顶点当前的最短距离用堆维护，这样每次从堆中取出的最小值就是下一次要使用的顶点。
复杂度：O(|E|log|V|)
使用优先队列的实现：

struct edge { int to, cost; };
typedef pair<int, int> P;

int d[MAX_V];
vector<edge> G[MAX_V];
int V;

void dijkstra(int s)
{
    priority_queue<P, vector<P>, greater<P> > que;
    fill(d, d + V, INF);
    d[s] = 0;
    que.push(P(0, s));
    while(!que.empty())
    {
        P p = que.top(); que.pop();
        int v = p.second;
        if(d[v] < p.first) continue;
        for(int i = 0; i < G[v].size(); i++)
        {
            edge e = G[v][i];
            if(d[e.to] > d[v] + e.cost)
            {
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to], e.to));
            }
        }
    }
}

当所有边的权值相等时，比如网格图上求最短路，可以使用BFS。这种情况下优先队列的效果等同于普通队列，最先出队的一定是最短距离的点。
另外，优先队列优化的Dijkstra和SPFA样子有点像，把二者对比一下可以看出：前者每个顶点只出队一次且最短距离已经确定，后者不一定；前者队列中可能有多个相同顶点（但参与排序的权值不同），后者队列中顶点唯一。

Floyd算法

Floyd算法是用来求解带权图中的多源最短路问题。算法的原理是动态规划。
d[i][j]为从i到j的最短距离，如果从i到j以k为中间点距离更短，则更新d[i][j]。
复杂度：O(N³)

void floyd()
{
    for(int k = 1; k <= N; k++)
        for(int i = 1; i <= N; i++)
            for(int j = 1; j <= N; j++)
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}