最短路問題的四種算法（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]);
}