最近在做PAT時發現圖論的一些題目需要對多條最短路徑進行篩選，一個直接的解決辦法是在發現最短路徑的時候就進行判斷，選出是否更換路徑；另一個通用的方法是先把所有的最短路徑記錄下來，然後逐個判斷。前者具有一定的難度並且不好排查BUG，因此我設計了一種基於Dijkstra的記錄所有最短路的簡捷演算法，用於解決此類題目。

我們知道，Dijkstra是解決單源最短路問題的，並且最基本的演算法僅能求出最短路的長度，而不能輸出路徑，本文基於Dinjkstra進行改進，使之能記錄源點到任意點的所有最短路徑。

使用vector<int>來記錄一條路徑，因為每個結點可能有多條最短路徑，因此把這些路徑都裝在一個vector中，因此可以用一個vector<vector<int> >來表示一個結點的所有最短路徑，把所有結點的最短路徑都存放起來，又需要一個vector容器，因此所有結點的所有最短路徑的集合可以用vector<vector<vector<int> > >來表示。

約定：結點編號為0到N-1，源點為0，到每個點的最短距離儲存在陣列minD[N]中。

在Dijkstra演算法初始化時，找出所有源點的鄰接點w並且把相應的最短距離minD[w]更新，同時初始化這些點w的第一條最短路徑0->w（實現方法為分別push_back 0和w）。接下來將會找到一個到源點最短的點v，並且把v併入集合，對v的所有未訪問的鄰接點，如果到達w的路徑(0->...->w)在包含v之後(0->...->v->w)變短，則刪除w之前所有的最短路徑，並且更新為到v的所有最短路徑加上w點（注意對每個到v的最短路徑都要這樣處理）；如果到達w的路徑在包含v之後長度不變，說明發現了一條新的最短路徑，在w原來最短路徑容器的基礎上再壓入一個新的最短路徑，這條路徑為所有到v的最短路徑加上w點。

經過這樣的運算，就可以得到所有結點的所有最短路徑了，下面以一個例項對演算法進行測試，並且附上原始碼。

題目：求下圖的源點0到所有結點的最短路徑。

輸入：

5 8
2 4 1
0 1 3
0 2 6
1 3 2
1 4 1
3 4 1
3 2 1
0 4 4

輸出：

原始碼為：

#include <iostream>
#include <stdio.h>
#include <vector>

using namespace std;

#define MAX 1001
#define INF 99999999

int G[MAX][MAX];
int minD[MAX];
int minDist;
int finalSet[MAX];

int main()
{
    int N,M;
    int v1,v2;
    int len;
    cin >> N >> M;
    for(int i = 0; i < N; i++){
        finalSet[i] = 0;
        minD[i] = INF;
        for(int j = 0; j < N; j++)
            G[i][j] = INF;
    }
    for(int i = 0; i < M; i++){
        scanf("%d%d%d",&v1,&v2,&len);
        G[v1][v2] = G[v2][v1] = len;
    }

    vector<vector<vector<int> > > nodes(N);

    // 設0為源點，計算從0到所有點的所有最短路徑
    finalSet[0] = 1;
    minD[0] = 0;
    // 首先把所有源點鄰接點的最短距離初始化為源點到這些點的距離
    for(int i = 1; i < N; i++){
        if(G[0][i] != INF) {
            minD[i] = G[0][i];
            vector<vector<int> > minPaths;
            minPaths.clear();
            vector<int> pathList;
            pathList.clear();
            pathList.push_back(0);
            pathList.push_back(i);
            minPaths.push_back(pathList);
            nodes[i] = minPaths;
        }
    }

    // 從所有minD中找出最小的，併入集合S，重複N-1次（源點已經加入集合）
    for(int i = 1; i < N; i++){
        minDist = INF;
        int v = -1; // 記錄到源點記錄最小的結點
        for(int w = 1; w < N; w++){
            if(!finalSet[w] && minDist > minD[w]){
                minDist = minD[w];
                v = w;
            }
        }
        if(v == -1) break; // v = -1說明找不到點了，當圖不連通時才會出現這種情況
        // 已經找到了到源點最近的點v，將其併入集合，並且考慮原來的最短距離0->...->W在加入了v之後有沒有可能變短
        // 如果變短了，就更新為0->...>v->W
        finalSet[v] = 1;
        for(int w = 1; w < N; w++){
            if(!finalSet[w]){
                int newD = minDist + G[v][w];
                if(newD < minD[w]){
                    minD[w] = newD;
                    vector<vector<int> > minPathsV = nodes[v];
                    vector<int> pathList;
                    nodes[w].clear();
                    for(int index = 0; index < minPathsV.size(); index++){
                        pathList = minPathsV[index];
                        pathList.push_back(w);
                        nodes[w].push_back(pathList);
                    }

                }else if(newD == minD[w]){

                    vector<vector<int> > minPathsV = nodes[v];
                    vector<int> pathList;
                    for(int index = 0; index < minPathsV.size(); index++){
                        pathList = minPathsV[index];
                        pathList.push_back(w);
                        nodes[w].push_back(pathList);
                    }

                }
            }
        }
    }
    for(int i = 1; i < N; i++){
        cout << "------------" << endl;
        cout << "0 to "<< i << ":" << endl;
        cout << "The miniest distance:" << endl << minD[i] << endl;
        cout << "The possible paths:" << endl;
        vector<vector<int> >minPaths = nodes[i];
        int size = minPaths.size();
        vector<int> pathList;
        for(int j = 0; j < size; j++){
            pathList = minPaths[j];
            int pathSize = pathList.size();
            for(int k = 0; k < pathSize - 1; k++){
                cout << pathList[k] << "->";
            }
            cout << pathList[pathSize - 1] << endl;
        }

    }

    return 0;
}