Dijkstra算法

Djkstra算法示例演示

下面我求下圖，從頂點v1到其他各個頂點的最短路徑

 

首先第一步，我們先聲明一個dis數組，該數組初始化的值為:

 

 

我們的頂點集T的初始化為：T={v1}

既然是求 v1頂點到其余各個頂點的最短路程，那就先找一個離 1 號頂點最近的頂點。通過數組 dis 可知當前離v1頂點最近是 v3頂點。當選擇了 2 號頂點后，dis[2]（下標從0開始）的值就已經從“估計值”變為了“確定值”，即 v1頂點到 v3頂點的最短路程就是當前 dis[2]值。將V3加入到T中。

為什么呢？因為目前離 v1頂點最近的是 v3頂點，並且這個圖所有的邊都是正數，那么肯定不可能通過第三個頂點中轉，使得 v1頂點到 v3頂點的路程進一步縮短了。因為 v1頂點到其它頂點的路程肯定沒有 v1到 v3頂點短.

OK，既然確定了一個頂點的最短路徑，下面我們就要根據這個新入的頂點V3會有出度，發現以v3 為弧尾的有： < v3,v4 >,那么我們看看路徑：v1–v3–v4的長度是否比v1–v4短，其實這個已經是很明顯的了，因為dis[3]代表的就是v1–v4的長度為無窮大，而v1–v3–v4的長度為：10+50=60，所以更新dis[3]的值,得到如下結果：

 

因此 dis[3]要更新為 60。這個過程有個專業術語叫做“松弛”。即 v1頂點到 v4頂點的路程即 dis[3]，通過 < v3,v4> 這條邊松弛成功。這便是 Dijkstra 算法的主要思想：通過“邊”來松弛v1頂點到其余各個頂點的路程。

然后，我們又從除dis[2]和dis[0]外的其他值中尋找最小值，發現dis[4]的值最小，通過之前是解釋的原理，可以知道v1到v5的最短距離就是dis[4]的值，然后，我們把v5加入到集合T中，然后，考慮v5的出度是否會影響我們的數組dis的值，v5有兩條出度：< v5,v4>和 < v5,v6>,然后我們發現：v1–v5–v4的長度為：50，而dis[3]的值為60，所以我們要更新dis[3]的值.另外，v1-v5-v6的長度為：90，而dis[5]為100，所以我們需要更新dis[5]的值。更新后的dis數組如下圖：

 

然后，繼續從dis中選擇未確定的頂點的值中選擇一個最小的值，發現dis[3]的值是最小的，所以把v4加入到集合T中，此時集合T={v1,v3,v5,v4},然后，考慮v4的出度是否會影響我們的數組dis的值，v4有一條出度：< v4,v6>,然后我們發現：v1–v5–v4–v6的長度為：60，而dis[5]的值為90，所以我們要更新dis[5]的值，更新后的dis數組如下圖：

  

然后，我們使用同樣原理，分別確定了v6和v2的最短路徑，最后dis的數組的值如下：

 

因此，從圖中，我們可以發現v1-v2的值為：∞，代表沒有路徑從v1到達v2。所以我們得到的最后的結果為：

起點  終點    最短路徑    長度

v1    v2     無          ∞    

      v3     {v1,v3}    10

      v4     {v1,v5,v4}  50

      v5     {v1,v5}    30

      v6     {v1，v5,v4,v6} 60

 代碼：

　　版本一：與圖解匹配

void Test01()
{
    createDis();
    vector<int>pathNum(Size, 0);//用來保存最優路徑數量
    vector<int>path(Size, Start);//每個的點的上溯點是哪個點，用來找出最優路線圖
    vector<bool>index(Size, true);//用來標記是否已經遍歷過的點
    pathNum[Start] = 1;//最開始初始化有一條
    index[Start] = false;
    int first = 1;
    //在city[Start]的基礎上對city[Start][End]的最短距離，第一個出發點不是Start
    for (int i = 0; i < Size; ++i)
    {
        //先找出發點去往下一個最近的點
        int p = -1;
        int minD = INF;
        for (int j = 0; j < Size; ++j)
        {
            if (index[j] && minD > city[Start][j])
            {
                p = j;
                minD = city[Start][j];
                if (first)
                {
                    pathNum[p] = 1;
                    first = 0;
                }
            }
        }
        if (p == -1)
            break;//遍歷完畢
        index[p] = false;//已經遍歷過了
        //那么就遍歷點p能去往的點
        for (int j = 0; j < Size; ++j)
        {
            //更新點Start->j的距離
            if (index[j] && city[Start][j] > city[Start][p] + city[p][j])
            {
                city[Start][j] = city[Start][p] + city[p][j];
                path[j] = p;//更新路徑記錄，即到達j的最優路徑是經過點p的    
                pathNum[j] = pathNum[p];
            }
            else if (index[j] && city[Start][j] == city[Start][p] + city[p][j])//出現相同路徑
            {
                pathNum[j] += pathNum[p];//疊加最優路徑數量
            }
        }
    }
    cout << "最短路徑為：" << city[Start][End] << endl;
    cout << "最優路徑數量為：" << pathNum[End] << endl;
    int  k = End;
    //最優路線是反着的，如果要順着，則使用棧再存一次，這里就不做了
    cout << "最優路線為：" << endl << k << "->";
    while (k!=Start)
    {
        k = path[k];
        cout << k << "->";
    }
    cout << endl;

}

 

　　版本二：只有一點點改變，就是從出發點開始遍歷

void Test02()
{
    createDis();
    vector<int>pathNum(Size, 0);//用來保存最優路徑數量
    vector<int>path(Size, Start);//每個的點的上溯點是哪個點，用來找出最優路線圖
    vector<bool>index(Size, true);//用來標記是否已經遍歷過的點
    vector<int>Dis(Size, INF);
    pathNum[Start] = 1;//最開始初始化有一條
    Dis[Start] = 0;//Start開始出發

    //與Test01不同的是，此處在Dis的基礎上進行距離更新，第一次出發點一定是Start
    for (int i = 0; i < Size; ++i)
    {
        //先找出發點去往下一個最近的點
        int p = -1;
        int minD = INF;
        for (int j = 0; j < Size; ++j)
        {
            if (index[j] && minD > city[Start][j])
            {
                p = j;
                minD = city[Start][j];
            }
        }
        if (p == -1)
            break;//遍歷完畢
        index[p] = false;//已經遍歷過了
        //那么就遍歷點p能去往的點
        for (int j = 0; j < Size; ++j)
        {
            //更新點Start->j的距離
            if (index[j] && city[Start][j] > city[Start][p] + city[p][j])
            {
                city[Start][j] = city[Start][p] + city[p][j];
                path[j] = p;//更新路徑記錄，即到達j的最優路徑是經過點p的    
                pathNum[j] = pathNum[p];
            }
            else if (index[j] && city[Start][j] == city[Start][p] + city[p][j])//出現相同路徑
            {
                pathNum[j] += pathNum[p];//疊加最優路徑數量
            }
        }
    }
    cout << "最短路徑為：" << city[Start][End] << endl;
    cout << "最優路徑數量為：" << pathNum[End] << endl;
    int  k = End;
    //最優路線是反着的，如果要順着，則使用棧再存一次，這里就不做了
    cout << "最優路線為：" << endl << k << "->";
    while (k != Start)
    {
        k = path[k];
        cout << k << "->";
    }
    cout << endl;
}

 

　　其他：

#include <iostream>
#include <vector>

using namespace std;

#define INF 999999
#define Size 9
vector<vector<int>>city(Size, vector<int>(Size, INF));//將距離矩
陣初始化為0

int Start = 0, End = 8;
void createDis()
{
    //一般是輸入的，這里就直接初始化了
    city.clear();//清除
    city.push_back({ 0,        1,        5,        INF,    INF,    INF,    INF,    INF,    INF});
    city.push_back({ 1,        0,        3,        7,        5,        INF,    INF,    INF,    INF});
    city.push_back({ 5,        3,        0,        INF,    1,        7,        INF,    INF,    INF});
    city.push_back({ INF,    7,        INF,    0,        2,        INF,    3,        INF,    INF });
    city.push_back({ INF,    5,        1,        2,        0,        3,        6,        9,        INF});
    city.push_back({ INF,    INF,    7,        INF,    3,        0,        INF,    5,        INF});
    city.push_back({ INF ,    INF,    INF,    3,        6,        INF,    0,        2,        7});//7
    city.push_back({ INF ,    INF,    INF,    INF,    9,        5,        2,        0,        4});
    city.push_back({ INF ,    INF,    INF,    INF,    INF,    INF,    7,        4,        0 });
}


int main()
{
    Test01();
    Test02();
    return 0;
}