单源最短路径（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;
}

输入样例对应的输出结果：