碼上歡樂
相關內容    簡體    繁體

最短路算法詳解（Dijkstra/SPFA/Floyd）

本文轉載自   查看原文   2017-08-07 08:38   2368    算法/ 最短路徑


一、Dijkstra

Dijkstra單源最短路算法，即計算從起點出發到每個點的最短路。所以Dijkstra常常作為其他算法的預處理。

 使用鄰接矩陣的時間復雜度為O(n^2),用優先隊列的復雜度為O((m+n)logn)近似為O(mlogn)

(一)  過程

每次選擇一個未訪問過的到已經訪問過（標記為Known）的所有點的集合的最短邊，並用這個點進行更新，過程如下：

Dv為最短路，而Pv為前面的頂點。


1.     初始

V

 Known 

 Dv 

Pv

V1

     F

  0

 0

V2

     F

 ∞

0

V3

     F

 ∞

0

V4

      F

 ∞

0

V5  

     F

 ∞

0

V6

    F

 ∞

0

V7

   F

 ∞

0

 

2.     在v1被標記為已知后的表

V

Known

Dv 

 Pv

V1  

  T

0

0

V2

  F

2

V1

V3

  F

∞

0

V4

  F

1

V1

V5

  F

 ∞

0

V6

  F

 ∞

0

V7

  F

∞

0

3.     下一步選取v4並且標記為known，頂點v3,v5,v6,v7是鄰接的頂點，而他們實際上都需要調整。如表所示:

V

Known 

Dv 

Pv 

V1 

 T

0

0

V2

 F

2

V1

V3

 F

3

V4

V4

 T

1

V1

V5

 F

3

V4

V6

 F

9

V4

V7

 F

5

V4

 

4.     接下來選取v2,v4是鄰接點，但已經是known的，不需要調整，v5是鄰接的點但不做調整，因為經過v2的值為2+10=12而長為3的路徑已經是已知的。

V

Known 

Dv 

Pv 

V1

  T

 0

0

V2

 T 

 2

V1

V3

 F

 3

V4

V4

 T

 1

V1

V5

 F

 3

V4

V6

 F

 9

V4

V7

 F

 5

V4

 

5.     接下來選取v5，值為3，v7 3+6>5不需調整，然后選取v3，對v6的距離下調到3+5=8

V

Known

Dv 

Pv 

V1

 T

0

0

V2

 T

2

V1

V3

 T

3

V4

V4

 T

1

V1

V5

 T

3

V4

V6

 F

8

V3

V7 

 F

5

V4

 

6.     再選下一個頂點是v7，v6變為5+1=6

V

Known

Dv

 Pv 

V1 

 T

0

0

V2

 T 

2

V1

V3

 T

 3

 V4

V4

 T

 1

 V1

V5  

 T

 3

 V4

V6 

 F

 6

V7

V7

 T

 5

V4

 

7.     最后選取v6

V

Known

Dv

Pv

V1 

 T

 0

0 

V2

 T 

 2

V1 

V3

 T

 3

V4

V4

 T

 1

V1

V5

 T

 3

V4

V6

 T

 6

V7

V7

 T

 5

V4

 

(二)  局限性

Dijkstra沒辦法解決負邊權的最短路徑，如圖


運行完該算法后，從頂點1到頂點3的最短路徑為1,3，其長度為1，而實際上最短路徑為1,2,3，其長度為0.（因為過程中先選擇v3，v3被標記為已知，今后不再更新）

(三) 算法實現。

1．普通的鄰接表 以（HDU 1874 暢通工程續 SPFA || dijkstra）為例

用vis作為上面標記的known，dis記錄最短距離（記得初始化為一個很大的數）。

[cpp] view plain copy
print ?
  1. void dijkstra(int s)  
  2. {  
  3.     memset(vis,0,sizeof(vis));         
  4.     int cur=s;                     
  5.     dis[cur]=0;  
  6.     vis[cur]=1;  
  7.     for(int i=0;i<n;i++)  
  8.     {  
  9.         for(int j=0;j<n;j++)                       
  10.             if(!vis[j] && dis[cur] + map[cur][j] < dis[j])   //未被標記且比已知的短，可更新  
  11.                 dis[j]=dis[cur] + map[cur][j] ;  
  12.   
  13.         int mini=INF;  
  14.         for(int j=0;j<n;j++)                    
  15.             if(!vis[j] && dis[j] < mini)    //選擇下一次到已知頂點最短的點。  
  16.                 mini=dis[cur=j];  
  17.         vis[cur]=true;  
  18.     }     
  19. }  
void dijkstra(int s)
{
    memset(vis,0,sizeof(vis));       
    int cur=s;                   
    dis[cur]=0;
    vis[cur]=1;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)                     
            if(!vis[j] && dis[cur] + map[cur][j] < dis[j])   //未被標記且比已知的短，可更新
                dis[j]=dis[cur] + map[cur][j] ;

        int mini=INF;
        for(int j=0;j<n;j++)                  
            if(!vis[j] && dis[j] < mini)    //選擇下一次到已知頂點最短的點。
                mini=dis[cur=j];
        vis[cur]=true;
    }   
}

2.鄰接表+優先隊列。

要重載個比較函數.

[cpp] view plain copy
print ?
  1. struct point  
  2. {  
  3.     int val,id;  
  4.     point(int id,int val):id(id),val(val){}  
  5.     bool operator <(const point &x)const{  
  6.         return val>x.val;  
  7.     }  
  8. };  
  9. void dijkstra(int s)  
  10. {  
  11.     memset(vis,0,sizeof(vis));  
  12.     for(int i=0;i<n;i++)  
  13.         dis[i]=INF;   
  14.   
  15.     priority_queue<point> q;  
  16.     q.push(point(s,0));  
  17.     dis[s]=0;  
  18.     while(!q.empty())  
  19.     {  
  20.         int cur=q.top().id;  
  21.         q.pop();  
  22.         if(vis[cur]) continue;  
  23.         vis[cur]=true;  
  24.         for(int i=head[cur];i!=-1;i=e[i].next)  
  25.         {  
  26.             int id=e[i].to;  
  27.             if(!vis[id] && dis[cur]+e[i].val < dis[id])  
  28.             {  
  29.                 dis[id]=dis[cur]+e[i].val;  
  30.                 q.push(point(id,dis[id]));  
  31.             }  
  32.         }         
  33.     }  
  34. }  
struct point
{
    int val,id;
    point(int id,int val):id(id),val(val){}
    bool operator <(const point &x)const{
        return val>x.val;
    }
};
void dijkstra(int s)
{
    memset(vis,0,sizeof(vis));
    for(int i=0;i<n;i++)
        dis[i]=INF; 

    priority_queue<point> q;
    q.push(point(s,0));
    dis[s]=0;
    while(!q.empty())
    {
        int cur=q.top().id;
        q.pop();
        if(vis[cur]) continue;
        vis[cur]=true;
        for(int i=head[cur];i!=-1;i=e[i].next)
        {
            int id=e[i].to;
            if(!vis[id] && dis[cur]+e[i].val < dis[id])
            {
                dis[id]=dis[cur]+e[i].val;
                q.push(point(id,dis[id]));
            }
        }       
    }
}



二、SPFA（bellman-ford）

SPFA是bellman-ford的改進算法(隊列實現），效率也更高，故直接介紹SPFA。
相比於Dijkstra，SPFA可以計算帶負環的回路。
鄰接表的復雜度為：O(kE)E為邊數，k一般為2或3

（一）原理過程：


bellman-ford算法的基本思想是，對圖中除了源頂點s外的任意頂點u，依次構造從s到u的最短路徑長度序列dist[u],dis2[u]……dis(n-1)[u]，其中n是圖G的頂點數，dis1[u]是從s到u的只經過1條邊的最短路徑長度，dis2[u]是從s到u的最多經過G中2條邊的最短路徑長度……當圖G中沒有從源可達的負權圖時，從s到u的最短路徑上最多有n-1條邊。因此，
dist(n-1)[u]就是從s到u的最短路徑長度，顯然，若從源s到u的邊長為e(s,u)，則dis1[u]=e(s,u).對於k>1，dis（k)[u]滿足如下遞歸式，dis(k)[u]=min{dis(k-1)[v]+e(v,u)}.bellman-ford最短路徑就是按照這個遞歸式計算最短路的。
SPFA的實現如下：用數組dis記錄更新后的狀態，cnt記錄更新的次數，隊列q記錄更新過的頂點，算法依次從q中取出待更新的頂點v,按照dis(k)[u]的遞歸式計算。在計算過程中，一旦發現頂點K有cnt[k]>n，說明有一個從頂點K出發的負權圈，此時沒有最短路，應終止算法。否則，隊列為空的時候，算法得到G的各頂點的最短路徑長度。

（二）實現：

[cpp] view plain copy
print ?
  1. void SPFA(int s)    
  2. {    
  3.     for(int i=0;i<n;i++)    
  4.         dis[i]=INF;    
  5.     
  6.     bool vis[MAXN]={0};    
  7.         
  8.     vis[s]=true;    
  9.     dis[s]=0;    
  10.         
  11.     queue<int> q;    
  12.     q.push(s);    
  13.     while(!q.empty())    
  14.     {    
  15.         int cur=q.front();    
  16.         q.pop();    
  17.         vis[cur]=false;    
  18.         for(int i=0;i<n;i++)    
  19.         {    
  20.             if(dis[cur] + map[cur][i] < dis[i])    
  21.             {    
  22.                 dis[i]=dis[cur] + map[cur][i];    
  23.                 if(!vis[i])    
  24.                 {    
  25.                     q.push(i);    
  26.                     vis[i]=true;    
  27.                 }    
  28.             }               
  29.         }    
  30.     }    
  31. }    
void SPFA(int s)  
{  
    for(int i=0;i<n;i++)  
        dis[i]=INF;  

    bool vis[MAXN]={0};  

    vis[s]=true;  
    dis[s]=0;  

    queue<int> q;  
    q.push(s);  
    while(!q.empty())  
    {  
        int cur=q.front();  
        q.pop();  
        vis[cur]=false;  
        for(int i=0;i<n;i++)  
        {  
            if(dis[cur] + map[cur][i] < dis[i])  
            {  
                dis[i]=dis[cur] + map[cur][i];  
                if(!vis[i])  
                {  
                    q.push(i);  
                    vis[i]=true;  
                }  
            }             
        }  
    }  
}


[cpp] view plain copy
print ?
  1. void spfa(int s)  
  2. {  
  3.     memset(vis,0,sizeof(vis));  
  4.     for(int i=0;i<n;i++)  
  5.         dis[i]=INF;   
  6.   
  7.     queue<int> q;  
  8.     q.push(s);  
  9.     vis[s]=true;  
  10.     dis[s]=0;  
  11.     while(!q.empty())  
  12.     {  
  13.         int cur=q.front();  
  14.         q.pop();  
  15.         vis[cur]=false;  
  16.         for(int i=head[cur];i!=-1;i=e[i].next)  
  17.         {  
  18.             int id=e[i].to;  
  19.             if(dis[id] > dis[cur]+e[i].val)  
  20.             {  
  21.                 dis[id] = dis[cur] + e[i].val;  
  22.                 if(!vis[id])  
  23.                 {  
  24.                     vis[id]=true;  
  25.                     q.push(id);  
  26.                 }  
  27.             }  
  28.         }  
  29.     }  
  30. }  
void spfa(int s)
{
    memset(vis,0,sizeof(vis));
    for(int i=0;i<n;i++)
        dis[i]=INF; 

    queue<int> q;
    q.push(s);
    vis[s]=true;
    dis[s]=0;
    while(!q.empty())
    {
        int cur=q.front();
        q.pop();
        vis[cur]=false;
        for(int i=head[cur];i!=-1;i=e[i].next)
        {
            int id=e[i].to;
            if(dis[id] > dis[cur]+e[i].val)
            {
                dis[id] = dis[cur] + e[i].val;
                if(!vis[id])
                {
                    vis[id]=true;
                    q.push(id);
                }
            }
        }
    }
}

3.上面的兩個都沒有對負圈的判斷，因為題目的限制就是正的。判斷負環代碼如下：以（ZOJ 2770 Burn the Linked Camp 差分約束）為例

[cpp] view plain copy
print ?
  1. bool spfa()    
  2. {    
  3.     for(int i=0;i<=n;i++)    
  4.         dis[i]=INF;    
  5.     
  6.     bool vis[MAXN]={0};    
  7.     int cnt[MAXN]={0};    
  8.     queue<int> q;    
  9.     dis[0]=0;    
  10.     vis[0]=true;    
  11.     cnt[0]=1;    
  12.     q.push(0);    
  13.     
  14.     while(!q.empty())    
  15.     {    
  16.         int cur=q.front();    
  17.         q.pop();    
  18.         vis[cur]=false;    
  19.     
  20.         for(int i=head[cur];i!=-1;i=e[i].next)    
  21.         {    
  22.             int id=e[i].to;    
  23.             if(dis[cur] + e[i].val > dis[id])    
  24.             {    
  25.                 dis[id]=dis[cur]+e[i].val;    
  26.                 if(!vis[id])    
  27.                 {    
  28.                     cnt[id]++;    
  29.                     if(cnt[cur] > n)    
  30.                         return false;    
  31.                     vis[id]=true;    
  32.                     q.push(id);    
  33.                 }    
  34.             }    
  35.         }    
  36.     }    
  37.     return true;    
  38. }   
bool spfa()  
{  
    for(int i=0;i<=n;i++)  
        dis[i]=INF;  

    bool vis[MAXN]={0};  
    int cnt[MAXN]={0};  
    queue<int> q;  
    dis[0]=0;  
    vis[0]=true;  
    cnt[0]=1;  
    q.push(0);  

    while(!q.empty())  
    {  
        int cur=q.front();  
        q.pop();  
        vis[cur]=false;  

        for(int i=head[cur];i!=-1;i=e[i].next)  
        {  
            int id=e[i].to;  
            if(dis[cur] + e[i].val > dis[id])  
            {  
                dis[id]=dis[cur]+e[i].val;  
                if(!vis[id])  
                {  
                    cnt[id]++;  
                    if(cnt[cur] > n)  
                        return false;  
                    vis[id]=true;  
                    q.push(id);  
                }  
            }  
        }  
    }  
    return true;  
}

（三）：優化

SLF（Small Label First）是指在入隊時如果當前點的dist值小於隊首， 則插入到隊首， 否則插入到隊尾。
LLL不太常用，我也沒研究。

（四）應用：

眼見的同學應該發現了，上面的差分約束四個字，是的SPFA可以很好的實現差分約束系統。

三、floyd

全稱Floyd-Warshall。記得離散數學里面有Warshall算法，用來計算傳遞閉包。而數據結構每次都簡稱floyd，當時就覺得兩個都差不多，有神馬關系，后來google一下發現是同一個算法。。。。改個名字出來走江湖啊！！！！！
這個算法用於求所有點對的最短距離。比調用n次dijkstra的優點在於代碼簡單。
時間復雜度為O(n^3)

（一）原理過程：

這是一個dp（動態規划的過程）
dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
即從頂點i到j且經過頂點k的最短路徑長度。

（二）實現：

[cpp] view plain copy
print ?
  1. void floyd()  
  2. {  
  3.     for(int k=0;k<n;k++)  
  4.         for(int i=0;i<n;i++)  
  5.             for(int j=0;j<n;j++)  
  6.                 dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);  
  7. }  
void floyd()
{
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
}




四、其他

如走迷宮經常用的BFS，以一個點出發，向外擴散。

如：

UVA 10047 - TheMonocycle BFS

HDU 1728逃離迷宮 BFS

POJ3984迷宮問題 BFS

UVA 11624 - Fire!圖BFS



除了上面的

HDU 1874暢通工程續 SPFA || dijkstra||floyd

還有：

UVA11280 - Flying to Fredericton SPFA變形

UVA11090 - Going in Cycle!! SPFA

UVA10917 Walk Through the Forest SPFA

POJ 3259Wormholes鄰接表的SPFA判斷負權回路

POJ 1932XYZZY (ZOJ 1935)SPFA+floyd

UVA11374 Airport Express SPFA||dijkstra

 

UVA11367 - Full Tank? dijkstra+DP

 POJ 1511Invitation Cards (ZOJ 2008)使用優先隊列的dijkstra

POJ 3268Silver Cow Party (Dijkstra~)

POJ 2387Til the Cows Come Home (Dijkstra)

UVA10603 - Fill BFS~

 




免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 最短路算法 ：Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法 詳解 圖的最短路徑：Dijkstra、Bellman-Ford、SPFA、Floyd、A*算法 Dijkstra最短路算法詳解 最短路徑-Dijkstra算法與Floyd算法 圖的最短路徑——dijkstra算法和Floyd算法 最短路徑—Dijkstra算法和Floyd算法 最短路徑—Dijkstra算法和Floyd算法 最短路徑—Dijkstra算法和Floyd算法 最短路徑之Dijkstra算法和Floyd-Warshall算法 最短路徑（dijkstra 與 Floyd）
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM