最短路算法模板

（轉自yxc https://www.acwing.com/blog/content/27/）

我們只需考慮有向圖上的算法，因爲無向圖是特殊的有向圖。我們可以將所有無向邊 u↔v，都拆分成兩條有向邊：u←v 和 u→v。
爲了方便敘述，我們做如下約定：n 表示圖中點數，m 表示圖中邊數。

圖的存儲

圖一般有兩種存儲方式：

鄰接矩陣。開個二維數組，g[i][j] 表示點 i 和點 j 之間的邊權。
鄰接表。鄰接表有兩種常用寫法，我推薦第二種，代碼更簡潔，效率也更高，後面有代碼模板：
(1) 二維vector：vector<vector<int>> edge，edge[i][j] 表示第 i 個點的第 j條鄰邊。
(2) 數組模擬鄰接表：爲每個點開個單鏈表，分別存儲該點的所有鄰邊。

最短路算法

最短路算法分爲兩大類：

單源最短路，常用算法有：
(1) dijkstra，只有所有邊的權值爲正時纔可以使用。在稠密圖上的時間複雜度是 O()，稀疏圖上的時間複雜度是 O(mlogn)。
(2) spfa，不論邊權是正的還是負的，都可以做。算法平均時間複雜度是 O(km)，k 是常數。 強烈推薦該算法。
多源最短路，一般用floyd算法。代碼很短，三重循環，時間複雜度是 O()。

算法模板

我們以 poj2387 Til the Cows Come Home 題目爲例，給出上述所有算法的模板。

題目大意
給一張無向圖，nn個點 m 條邊，求從1號點到 n 號點的最短路徑。 
輸入中可能包含重邊。

dijkstra算法 O()
最裸的dijkstra算法，不用堆優化。每次暴力循環找距離最近的點。
只能處理邊權爲正數的問題。
圖用鄰接矩陣存儲。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010, M = 2000010, INF = 1000000000;

int n, m;
int g[N][N], dist[N];   // g[][]存儲圖的鄰接矩陣, dist[]表示每個點到起點的距離
bool st[N];     // 存儲每個點的最短距離是否已確定

void dijkstra()
{
    for (int i = 1; i <= n; i++) dist[i] = INF;
    dist[1] = 0;
    for (int i = 0; i < n; i++)
    {
        int id, mind = INF;
        for (int j = 1; j <= n; j++)
            if (!st[j] && dist[j] < mind)
            {
                mind = dist[j];
                id = j;
            }
        st[id] = 1;
        for (int j = 1; j <= n; j++) dist[j] = min(dist[j], dist[id] + g[id][j]);
    }
}

int main()
{
    cin >> m >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            g[i][j] = INF;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    dijkstra();
    cout << dist[n] << endl;
    return 0;
}

dijkstra+heap優化 O(mlogn)
用堆維護所有點到起點的距離。時間複雜度是 O(mlogn)。
這裏我們可以手寫堆，可以支持對堆中元素的修改操作，堆中元素個數不會超過 n。也可以直接使用STL中的priority_queue，但不能支持對堆中元素的修改，不過我們可以將所有修改過的點直接插入堆中，堆中會有重複元素，但堆中元素總數不會大於 m。
只能處理邊權爲正數的問題。
圖用鄰接表存儲。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <functional>

using namespace std;

const int N = 1010, M = 2000010, INF = 1000000000;

int n, m;
int dist[N];    // 存儲每個點到起點的距離
int h[N], e[M], v[M], ne[M], idx;   // 數組模擬鄰接表

void add(int a, int b, int c)
{
    e[idx] = b, v[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void dijkstra_heap()
{
    priority_queue < pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> heap;
    for (int i = 1; i <= n; i++) dist[i] = INF;
    dist[1] = 0;
    heap.push(make_pair(dist[1], 1));
    while (heap.size())
    {
        pair<int, int> t = heap.top();
        heap.pop();
        if (t.first > dist[t.second]) continue;
        for (int i = h[t.second]; i != -1; i = ne[i])
            if (dist[e[i]] > t.first + v[i])
            {
                dist[e[i]] = t.first + v[i];
                heap.push(make_pair(dist[e[i]], e[i]));
            }
    }
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> m >> n;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b, a, c);
    }
    dijkstra_heap();
    cout << dist[n] << endl;
    return 0;
}

spfa算法 O(km)
bellman-ford算法的優化版本，可以處理存在負邊權的最短路問題。
最壞情況下的時間複雜度是 O(nm)，但實踐證明spfa算法的運行效率非常高，期望運行時間是 O(km)，其中 k 是常數。
但需要注意的是，在網格圖中，spfa算法的效率比較低，如果邊權爲正，則儘量使用 dijkstra 算法。

圖採用鄰接表存儲。
隊列爲手寫的循環隊列。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 1010, M = 2000010, INF = 1000000000;

int n, m;
int dist[N], q[N];      // dist表示每個點到起點的距離, q 是隊列
int h[N], e[M], v[M], ne[M], idx;       // 鄰接表
bool st[N];     // 存儲每個點是否在隊列中

void add(int a, int b, int c)
{
    e[idx] = b, v[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void spfa()
{
    int hh = 0, tt = 0;
    for (int i = 1; i <= n; i++) dist[i] = INF;
    dist[1] = 0;
    q[tt++] = 1, st[1] = 1;
    while (hh != tt)
    {
        int t = q[hh++];
        st[t] = 0;
        if (hh == n) hh = 0;
        for (int i = h[t]; i != -1; i = ne[i])
            if (dist[e[i]] > dist[t] + v[i])
            {
                dist[e[i]] = dist[t] + v[i];
                if (!st[e[i]])
                {
                    st[e[i]] = 1;
                    q[tt++] = e[i];
                    if (tt == n) tt = 0;
                }
            }
    }
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> m >> n;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b, a, c);
    }
    spfa();
    cout << dist[n] << endl;
    return 0;
}

floyd算法 O()
標準弗洛伊德算法，三重循環。循環結束之後 d[i][j]d[i][j] 存儲的就是點 ii 到點 jj 的最短距離。
需要注意循環順序不能變：第一層枚舉中間點，第二層和第三層枚舉起點和終點。

由於這道題目的數據範圍較大，點數最多有1000個，因此floyd算法會超時。
但我們的目的是給出算法模板哦~

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 1010, M = 2000010, INF = 1000000000;

int n, m;
int d[N][N];    // 存儲兩點之間的最短距離

int main()
{
    cin >> m >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            d[i][j] = i == j ? 0 : INF;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        d[a][b] = d[b][a] = min(c, d[a][b]);
    }
    // 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]);
    cout << d[1][n] << endl;
    return 0;
}