【坐在馬桶上看算法】算法7：Dijkstra最短路算法

       上週咱們介紹了神奇的只有五行的Floyd最短路算法，它能夠方便的求得任意兩點的最短路徑，這稱爲「多源最短路」。本週來來介紹指定一個點（源點）到其他各個頂點的最短路徑，也叫作「單源最短路徑」。例如求下圖中的1號頂點到二、三、四、五、6號頂點的最短路徑。

       與Floyd-Warshall算法同樣這裏仍然使用二維數組e來存儲頂點之間邊的關係，初始值以下。

       咱們還須要用一個一維數組dis來存儲1號頂點到其他各個頂點的初始路程，以下。

       咱們將此時dis數組中的值稱爲最短路的「估計值」。

       既然是求1號頂點到其他各個頂點的最短路程，那就先找一個離1號頂點最近的頂點。經過數組dis可知當前離1號頂點最近是2號頂點。當選擇了2號頂點後，dis[2]的值就已經從「估計值」變爲了「肯定值」，即1號頂點到2號頂點的最短路程就是當前dis[2]值。爲何呢？你想啊，目前離1號頂點最近的是2號頂點，而且這個圖全部的邊都是正數，那麼確定不可能經過第三個頂點中轉，使得1號頂點到2號頂點的路程進一步縮短了。由於1號頂點到其它頂點的路程確定沒有1號到2號頂點短，對吧O(∩_∩)O~

       既然選了2號頂點，接下來再來看2號頂點有哪些出邊呢。有2->3和2->4這兩條邊。先討論經過2->3這條邊可否讓1號頂點到3號頂點的路程變短。也就是說如今來比較dis[3]和dis[2]+e[2][3]的大小。其中dis[3]表示1號頂點到3號頂點的路程。dis[2]+e[2][3]中dis[2]表示1號頂點到2號頂點的路程，e[2][3]表示2->3這條邊。因此dis[2]+e[2][3]就表示從1號頂點先到2號頂點，再經過2->3這條邊，到達3號頂點的路程。

       咱們發現dis[3]=12，dis[2]+e[2][3]=1+9=10，dis[3]>dis[2]+e[2][3]，所以dis[3]要更新爲10。這個過程有個專業術語叫作「鬆弛」。即1號頂點到3號頂點的路程即dis[3]，經過2->3這條邊鬆弛成功。這即是Dijkstra算法的主要思想：經過「邊」來鬆弛1號頂點到其他各個頂點的路程。

       同理經過2->4（e[2][4]），能夠將dis[4]的值從∞鬆弛爲4（dis[4]初始爲∞，dis[2]+e[2][4]=1+3=4，dis[4]>dis[2]+e[2][4]，所以dis[4]要更新爲4）。

       剛纔咱們對2號頂點全部的出邊進行了鬆弛。鬆弛完畢以後dis數組爲：

       接下來，繼續在剩下的三、四、5和6號頂點中，選出離1號頂點最近的頂點。經過上面更新過dis數組，當前離1號頂點最近是4號頂點。此時，dis[4]的值已經從「估計值」變爲了「肯定值」。下面繼續對4號頂點的全部出邊（4->3，4->5和4->6）用剛纔的方法進行鬆弛。鬆弛完畢以後dis數組爲：

       繼續在剩下的三、5和6號頂點中，選出離1號頂點最近的頂點，此次選擇3號頂點。此時，dis[3]的值已經從「估計值」變爲了「肯定值」。對3號頂點的全部出邊（3->5）進行鬆弛。鬆弛完畢以後dis數組爲：

       繼續在剩下的5和6號頂點中，選出離1號頂點最近的頂點，此次選擇5號頂點。此時，dis[5]的值已經從「估計值」變爲了「肯定值」。對5號頂點的全部出邊（5->4）進行鬆弛。鬆弛完畢以後dis數組爲：

       最後對6號頂點全部點出邊進行鬆弛。由於這個例子中6號頂點沒有出邊，所以不用處理。到此，dis數組中全部的值都已經從「估計值」變爲了「肯定值」。

       最終dis數組以下，這即是1號頂點到其他各個頂點的最短路徑。

       OK，如今來總結一下剛纔的算法。算法的基本思想是：每次找到離源點（上面例子的源點就是1號頂點）最近的一個頂點，而後以該頂點爲中心進行擴展，最終獲得源點到其他全部點的最短路徑。基本步驟以下：

• 將全部的頂點分爲兩部分：已知最短路程的頂點集合P和未知最短路徑的頂點集合Q。最開始，已知最短路徑的頂點集合P中只有源點一個頂點。咱們這裏用一個book[ i ]數組來記錄哪些點在集合P中。例如對於某個頂點i，若是book[ i ]爲1則表示這個頂點在集合P中，若是book[ i ]爲0則表示這個頂點在集合Q中。

• 設置源點s到本身的最短路徑爲0即dis=0。若存在源點有能直接到達的頂點i，則把dis[ i ]設爲e[s][ i ]。同時把全部其它（源點不能直接到達的）頂點的最短路徑爲設爲∞。

• 在集合Q的全部頂點中選擇一個離源點s最近的頂點u（即dis[u]最小）加入到集合P。並考察全部以點u爲起點的邊，對每一條邊進行鬆弛操做。例如存在一條從u到v的邊，那麼能夠經過將邊u->v添加到尾部來拓展一條從s到v的路徑，這條路徑的長度是dis[u]+e[u][v]。若是這個值比目前已知的dis[v]的值要小，咱們能夠用新值來替代當前dis[v]中的值。

• 重複第3步，若是集合Q爲空，算法結束。最終dis數組中的值就是源點到全部頂點的最短路徑。

       完整的Dijkstra算法代碼以下：

#include <stdio.h>
int main()
{
    int e[10][10],dis[10],book[10],i,j,n,m,t1,t2,t3,u,v,min;
    int inf=99999999; //用inf(infinity的縮寫)存儲一個咱們認爲的正無窮值
    //讀入n和m，n表示頂點個數，m表示邊的條數
    scanf("%d %d",&n,&m);
                                                                  
    //初始化
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            if(i==j) e[i][j]=0;
              else e[i][j]=inf;
                                                                            
    //讀入邊
    for(i=1;i<=m;i++)
    {
        scanf("%d %d %d",&t1,&t2,&t3);
        e[t1][t2]=t3;
    }
    //初始化dis數組，這裏是1號頂點到其他各個頂點的初始路程
    for(i=1;i<=n;i++)
        dis[i]=e[1][i];
    //book數組初始化
    for(i=1;i<=n;i++)
        book[i]=0;
    book[1]=1;
                                                                  
    //Dijkstra算法核心語句
    for(i=1;i<=n-1;i++)
    {
        //找到離1號頂點最近的頂點
        min=inf;
        for(j=1;j<=n;j++)
        {
            if(book[j]==0 && dis[j]<min)
            {
                min=dis[j];
                u=j;
            }
        }
        book[u]=1;
        for(v=1;v<=n;v++)
        {
            if(e[u][v]<inf)
            {
                if(dis[v]>dis[u]+e[u][v])
                    dis[v]=dis[u]+e[u][v];
            }
        }
    }
                                                                  
    //輸出最終的結果
    for(i=1;i<=n;i++)
        printf("%d ",dis[i]);
                                                                      
    getchar();
    getchar();
    return 0;
}

       能夠輸入如下數據進行驗證。第一行兩個整數n  m。n表示頂點個數（頂點編號爲1~n），m表示邊的條數。接下來m行表示，每行有3個數x y z。表示頂點x到頂點y邊的權值爲z。

6 9
1 2 1
1 3 12
2 3 9
2 4 3
3 5 5
4 3 4
4 5 13
4 6 15
5 6 4

       運行結果是

0 1 8 4 13 17

   經過上面的代碼咱們能夠看出，這個算法的時間複雜度是O(N²)。其中每次找到離1號頂點最近的頂點的時間複雜度是O(N)，這裏咱們能夠用「堆」（之後再說）來優化，使得這一部分的時間複雜度下降到O(logN)。另外對於邊數M少於N²的稀疏圖來講（咱們把M遠小於N²的圖稱爲稀疏圖，而M相對較大的圖稱爲稠密圖），咱們能夠用鄰接表（這是個神馬東西？不要着急，下週再仔細講解）來代替鄰接矩陣，使得整個時間複雜度優化到O( (M+N)logN )。請注意！在最壞的狀況下M就是N²，這樣的話MlogN要比N²還要大。可是大多數狀況下並不會有那麼多邊，所以(M+N)logN要比N²小不少。

歡迎轉載，碼字不容易啊，轉載麻煩註明出處
【啊哈！算法】系列7：Dijkstra最短路算法
http://ahalei.blog.51cto.com/4767671/1387799