背景知識

圖簡介

圖由節點和邊組成，邊有方向的圖稱為有向圖，邊沒有方向的圖稱為無向圖，最短路徑演算法裡可以把無向圖視為雙向連線的有向圖。
邊有權重的圖稱為有權圖，邊沒有權重的圖稱為無權圖，無權圖可以視為邊的權重均為1的圖。

單源點最短路徑

給定圖中的一個節點，求該節點到其他所有節點的最短路徑。

Dijkstra演算法

概述

Dijkstra屬於單源點最短路徑演算法，時間複雜度為O(V^2)，適用於有權圖、無權圖、有向圖、無向圖（無權圖視權為1，無向圖視連線為雙向連線），但是不適用於含負權邊的圖。通過分別以每個節點為源點，可以求圖中所有節點兩兩之間的最短路徑(和Floyd-Warshall演算法功能相同）。

核心思想

Dijkstra屬於貪心演算法，演算法通過構建最短路徑樹來求解，維護兩個集合，集合V用來儲存已經在最短路徑樹上的節點，集合U儲存不在最短路徑樹上的節點，每次遍歷V-U節點對(v,u)，尋找使得dis[v] + edge(v-u)最小的(v,u), v記錄為u的前驅，dis[u] = dis[v] + edge(v-u).重複此過程，直到U為空

詳細步驟

Step1：初始化，將源點加入集合V中，將其他節點加入集合U中，dis陣列初始化為INT_MAX, dis[src] = 0;
Step2：對V中的每個節點(v)：遍歷集合U中的節點(u)，找到使dis[v] + edge(v-u)最小的(v-u)，執行v記錄為u的前驅，dis[u] = dis[v] + edge(v-u)。
Step3：重複Step2，直到V為空，此時dis陣列記錄了每個節點距離源點的距離。

演算法正確性證明

證明使用歸納法證明
Step1：n=1時，成立。集合V中第一個節點是源點，容易理解，第二個加入的節點肯定是距離源點最近的節點。
Step2：假設n=k-1時成立，下面使用反證法證明n=k時也成立。
………………假設n=k時不成立，即對u，U集合中存在u2使得dis[u2] + edge(u2,u) < dis[v] + edge(v,u)。即存在dis[v2] + edge(v2-u2) + edge(u2,u) < dis[v] + edge(v,u)。那麼可得dis[v2] + edge(v2-u2) < dis[v] + edge(v,u).由於dis[v] + edge(v,u)是我們找到的最小值，所以該等式顯然不成立，所以n=k必然也是成立的，證明完畢。

為什麼dijkstra不能適用於含負權邊的圖

因為存在負權邊時，上述證明中的反證法就不能證偽了，如果edge(v2-u2)為負數，那麼dis[v2] + edge(v2-u2) < dis[v] + edge(v,u)就有可能成立了。不好理解的話，可以把edge(v2-u2) 假定為非常小的負數，把edge(v,u) 假定為正數。
下面給出一個負權邊的例子

可以看到dis[2] 應該為1，最短路徑為0-1-2,但是dijkstra計算出來dis[2]為2，最短路勁為0-2.

C++實現：

#include <iostream>
#include <vector>
#include <unordered_set>
#include <stack>

using namespace std;

class Solution
{
public:
    vector<int> dijkstra(int src, vector<vector<int>> &graph, vector<int> &preNode)
    {
        ///initialization
        preNode = vector<int>(graph.size(), -1);
        vector<int> distToSrc(graph.size());
        unordered_set<int> visitedNodes;
        unordered_set<int> unvisitedNodes;
        for(int i = 0; i < graph.size(); i++)
        {
            unvisitedNodes.insert(i);
        }
        unvisitedNodes.erase(src);
        visitedNodes.insert(src);
        distToSrc[src] = 0;
        preNode[src] = -1;

        ///do greedy, find most closed node each turn
        while(!unvisitedNodes.empty())
        {
            int minNode = 0;
            int previousNode = 0;
            int minDistance = INT_MAX;
            ///traverse each v-u,v in visitedNodes, u in unvisitedNodes
            for(auto vNode: visitedNodes)
            {
                for(auto unNode: unvisitedNodes)
                {
                    if(graph[vNode][unNode] && distToSrc[vNode] + graph[vNode][unNode] < minDistance)
                    {
                        minDistance = distToSrc[vNode] + graph[vNode][unNode];
                        minNode = unNode;
                        previousNode = vNode;
                    }
                }
            }
            visitedNodes.insert(minNode);
            unvisitedNodes.erase(minNode);
            distToSrc[minNode] = minDistance;
            preNode[minNode] = previousNode;
        }
        return distToSrc;
    }

    int printPath()
    {
        vector<vector<int>> graph{{0, 4, 0, 0, 0, 0, 0, 8, 0},
                                  {4, 0, 8, 0, 0, 0, 0, 11, 0},
                                  {0, 8, 0, 7, 0, 4, 0, 0, 2},
                                  {0, 0, 7, 0, 9, 14, 0, 0, 0},
                                  {0, 0, 0, 9, 0, 10, 0, 0, 0},
                                  {0, 0, 4, 14, 10, 0, 2, 0, 0},
                                  {0, 0, 0, 0, 0, 2, 0, 1, 6},
                                  {8, 11, 0, 0, 0, 0, 1, 0, 7},
                                  {0, 0, 2, 0, 0, 0, 6, 7, 0}};

        vector<int> preNode;
        auto dists = dijkstra(0, graph, preNode);
        for(int i = 0; i < dists.size(); i++)
        {
            cout << i << " " << dists[i] << ": ";
            int node = i;
            stack<int> s;
            while(node != -1)
            {
                s.push(node);
                node = preNode[node];
            }
            while(!s.empty())
            {
                cout << s.top() << " ";
                s.pop();
            }
            cout << endl;
        }
        return 0;
    }
};

int main()
{
    return Solution().printPath();
}

The End