單源最短路徑（Dijkstra）算法

Dijkstra 算法是一種貪心算法。

假定源點爲 u，頂點集合 V 被劃分爲兩部分：S 和 V-S，其中 S中的頂點到源點的最短路徑的長度已經確定，V-S中的頂點到源點的最短路徑待定。

思想：

1. 每次從 V-S 中選擇一個距離 源點最近的頂點，將其加入到 S 中，並從 V-S 中刪除這個頂點；

2. 因爲 S 中加入了新的頂點，更新 V-S 中其他所有點頂到源點的距離；

3. 當 V-S 爲空時算法結束。

C++ 代碼

#include <iostream>
#include <limits>
#include <vector>

using namespace std;

const int INFINITE = numeric_limits<int>::max();

/* n：頂點個數（從 1 開始計數）
 * u：源點
 * C：帶權鄰接矩陣
 * dist：記錄某頂點與源點 u 的最短路徑長度
 * p：記錄某頂點到源點的最短路徑上的該頂點的前驅頂點
*/
void Dijkstra(int n, int u, float *dist, int *p, int **C) {
    bool s[n];// 用於標記頂點是否加入了 S

    for(int i=1; i <= n; i++) {
        s[i] = false;// 處源點外，所有頂點都還未加入 S，在 V-S 中
        dist[i] = C[u][i];// 初始化所有其他頂點到源點的距離
        // 初始化所有其他頂點到源點的前驅
        if(INFINITE == dist[i]) {
            p[i] = -1;
        } else {
            p[i] = u;
        }
    }

    s[u] = true;// 源點 u 默認加入 S
    dist[u] = 0;// 源點 u 到自己的距離爲 0

    for(int i=1; i <= n; i++) {// 遍歷所有其他頂點
        int minDist = INFINITE;
        int t = u;
        for(int j=1; j <= n; j++) {// 在 V-S 中尋找距離源點最近的點 t
            if(!s[j] && (dist[j]<minDist)) {
                t = j;
                minDist = dist[j];
            }
        }
        if(t == u)// 表示剩餘的頂點要麼到源點不可達，要麼已經全部找到了最短距離都加入到 S 了。
            break;
        s[t] = true;// 找到這個頂點後，將其加入到 S
        for(int j=1; j <= n; j++) {// 因爲有新的頂點加入到 S，故更新其他所有未加入的頂點（V-S中的頂點）到源點的距離和前驅
            if(!s[j] && C[t][j]<INFINITE)
                if(dist[j] > (dist[t]+C[t][j])) {
                    dist[j] = dist[t]+C[t][j];
                    p[j] = t;
                }
        }
    }
}

int** getMatC(int n, int m) {// 輸入頂點個數，邊個數，得到有向帶權鄰接矩陣
    int **C = new int*[n+1];
    for(int i=0; i <= n; i++) {
        C[i] = new int[n+1]();
        for(int j=0; j <= n; j++)
            if(i != j)
                C[i][j] = INFINITE;
    }
    for(int i=1; i <= m; i++) {
        int x, y;
        int distance = 0;
        cin >> x >> y >> distance;
        if(1 <= x && x <= n && 1 <= y && y <= n)
            C[x][y] = distance;
    }
    return C;
    // 輸入樣例：（有向帶權圖）
    //   | 1  2  3  4  5
    //---------------------
    // 1 | 0  8  32 ∞  ∞
    // 2 | 12 0  16 15 ∞
    // 3 | ∞  29 0  ∞  13
    // 4 | ∞  21 ∞  0  7
    // 5 | ∞  ∞  27 19 0
    /* 即：
    5 11 1
    1 2 8
    1 3 32
    2 1 12
    2 3 16
    2 4 15
    3 2 29
    3 5 13
    4 2 21
    4 5 7
    5 3 27
    5 4 19
    */
}

vector<int> getPath(int* p, int u, const int& v) {
    vector<int> path;
    path.push_back(v);
    int s = p[v];
    while(s != u) {
        path.push_back(s);
        s = p[s];
    }
    path.push_back(s);
    return path;
}

void printVec1D(const vector<int>& vec) {
    if(!vec.empty()) {
        for(int i = vec.size()-1; i > 0; i--)
            cout << vec[i] << " -> ";
        cout << vec[0] << endl;
    }
}

int main() {
    int n/*頂點數*/, m/*邊數*/, u/*源點*/;
    cin >> n >> m >> u;
    int **C = getMatC(n, m);
    if(NULL != C) {
        float dist[n+1];// 存放距離
        int path[n+1];// 存放前驅
        Dijkstra(n, u, dist, path, C);
        for(int i=1; i <= n; i++) {
            if(INFINITE != dist[i]) {
                if(i != u) {
                    cout << "頂點 " << u << " 到頂點 " << i << " 的距離是: " << dist[i] << endl;
                    cout << "路徑爲：";
                    printVec1D(getPath(path, u, i));
                }
            } else
                cout << "頂點 " << u << " 到頂點 " << i << " 不可達！" << endl;
        }
    }
    return 0;
}

輸入樣例對應的輸出結果：