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

圖論相關算法理解和總結

本文轉載自   查看原文   2016-03-14 21:27   6727    ACM_ac算法與函數/ ACM_圖論

晚上學習了一些圖論相關算法:

單源最短路徑算法:

Bellman-Ford 算法:

Bellman-Ford 算法是一種用於計算帶權有向圖中單源最短路徑（SSSP：Single-Source Shortest Path）的算法。該算法由 Richard Bellman 和 Lester Ford 分別發表於 1958 年和 1956 年，而實際上 Edward F. Moore 也在 1957 年發布了相同的算法，因此，此算法也常被稱為 Bellman-Ford-Moore 算法。

Bellman-Ford 算法和 Dijkstra 算法同為解決單源最短路徑的算法。對於帶權有向圖 G = (V, E)，Dijkstra 算法要求圖 G 中邊的權值均為非負，而 Bellman-Ford 算法能適應一般的情況（即存在負權邊的情況）。一個實現的很好的 Dijkstra 算法比 Bellman-Ford 算法的運行時間要低。

Bellman-Ford 算法采用動態規划（Dynamic Programming）進行設計，實現的時間復雜度為 O(V*E)，其中 V 為頂點數量，E 為邊的數量。Dijkstra 算法采用貪心算法（Greedy Algorithm）范式進行設計，普通實現的時間復雜度為 O(V2)，若基於 Fibonacci heap 的最小優先隊列實現版本則時間復雜度為 O(E + VlogV)。

Bellman-Ford 算法描述：

創建源頂點 v 到圖中所有頂點的距離的集合 distSet，為圖中的所有頂點指定一個距離值，初始均為 Infinite，源頂點距離為 0；
計算最短路徑，執行 V - 1 次遍歷；
對於圖中的每條邊：如果起點 u 的距離 d 加上邊的權值 w 小於終點 v 的距離 d，則更新終點 v 的距離值 d；
檢測圖中是否有負權邊形成了環，遍歷圖中的所有邊，計算 u 至 v 的距離，如果對於 v 存在更小的距離，則說明存在環；

 

代碼:

 1 //從頂點from指向頂點to的權值為cost的邊
 2 struct edge{
 3     int from,to,cost;
 4 };
 5 
 6 edge es[MAX_V];//邊
 7 
 8 int d[MAX_V];  //最短距離
 9 int V,E;       //V是頂點數,E是邊數
10 
11 //求解從頂點s出發到所有點的最短距離
12 void shortest_path(int s)
13 {
14     for(int i=0; i<V; i++)  
15         d[i] = INF;  //0x3f3f3f3f 
16     d[s]=0;
17     while(true){
18         bool update=false;
19         for(int i=0; i<E; i++){
20             edge e=es[i];
21             if(d[e.from]!=INF && d[e.to] >d[e.from]+e.cost){
22                 uopdate=true;
23             }
24         }
25         if(!update)
26             break;
27     }     
28 }

 

 

Dijkstra算法  

1.定義概覽 

Dijkstra(迪傑斯特拉)算法是典型的單源最短路徑算法，用於計算一個節點到其他所有節點的最短路徑。主要特點是以起始點為中心向外層層擴展，直到擴展到終點為止。Dijkstra算法是很有代表性的最短路徑算法，在很多專業課程中都作為基本內容有詳細的介紹，如數據結構，圖論，運籌學等等。注意該算法要求圖中不存在負權邊。

問題描述：在無向圖 G=(V,E) 中，假設每條邊 E[i] 的長度為 w[i]，找到由頂點 V0 到其余各點的最短路徑。（單源最短路徑）

 

2.算法描述

1)算法思想：設G=(V,E)是一個帶權有向圖，把圖中頂點集合V分成兩組，第一組為已求出最短路徑的頂點集合（用S表示，初始時S中只有一個源點，以后每求得一條最短路徑 , 就將加入到集合S中，直到全部頂點都加入到S中，算法就結束了），第二組為其余未確定最短路徑的頂點集合（用U表示），按最短路徑長度的遞增次序依次把第二組的頂點加入S中。在加入的過程中，總保持從源點v到S中各頂點的最短路徑長度不大於從源點v到U中任何頂點的最短路徑長度。此外，每個頂點對應一個距離，S中的頂點的距離就是從v到此頂點的最短路徑長度，U中的頂點的距離，是從v到此頂點只包括S中的頂點為中間頂點的當前最短路徑長度。

2)算法步驟：

a.初始時，S只包含源點，即S＝{v}，v的距離為0。U包含除v外的其他頂點，即:U={其余頂點}，若v與U中頂點u有邊，則<u,v>正常有權值，若u不是v的出邊鄰接點，則<u,v>權值為∞。

b.從U中選取一個距離v最小的頂點k，把k，加入S中（該選定的距離就是v到k的最短路徑長度）。

c.以k為新考慮的中間點，修改U中各頂點的距離；若從源點v到頂點u的距離（經過頂點k）比原來距離（不經過頂點k）短，則修改頂點u的距離值，修改后的距離值的頂點k的距離加上邊上的權。

d.重復步驟b和c直到所有頂點都包含在S中。

執行動畫過程如下圖

STL代碼:

 1 struct edge{int to, cost;};//圖的邊  
 2 typedef pair<int,int> P;//保存的結果，first為最短距離，second為相應頂點  
 3   
 4 int V;  
 5 vector<edge> G[MAX_V];  
 6 int d[MAX_V];  
 7   
 8 void dijkstra(int s){  
 9     //通過制定greater<P>參數,堆按照first從小到大的順序取出值
10     priority_queue<P,vector<P>,greater<P>> que;  
11     fill(d,d+V,INF);  
12     d[s]=0;  
13     que.push(P(0,s));  
14   
15     while(!que.empty()){  
16         P p=que.top(); que.pop();  
17         int v=p.second;  
18         for(int i=0;i<G[v].size;i++){  
19             edge e=G[v][i];  
20             if(d[e.to]>d[v]+e.cost){  
21                 d[e.to]=d[v]+e.cost;  
22                 que.push(P(d[e.to],e.to));  
23             }  
24         }  
25     }  
26 }

 代碼實現:

 1 #define INF 0x3f3f3f3f
 2 #define MAX 101
 3 
 4 int dis[MAX],vis[MAX];
 5 int mp[MAX][MAX];
 6 
 7 int dijkstra(int s,int e)
 8 {
 9     memset(vis,0,sizeof(vis));
10     for(int i=1; i<=e; i++)
11         dis[i]=mp[s][i];
12     dis[s]=0;
13     vis[s]=1;
14     while(true){
15         int min=INF;
16         int p;
17         for(int i=1; i<=e; i++){
18             if(!vis[i] && dis[i]<min){
19                 min=dis[i];
20                 p=i;
21             }
22         }
23         if(min==INF)
24             break;
25         vis[p]=1;
26         for(int i=1; i<=e; i++){
27             if(!vis[i] && dis[i]>min+mp[p][i])
28                 dis[i]=min+mp[p][i];
29         }
30     }
31 }

 

SPFA: 

是一種求單源最短路的算法

幾乎所有的最短路算法其步驟都可以分為兩步

1.初始化

2.松弛操作

判斷有無負環：

　　如果某個點進入隊列的次數超過N次則存在負環（SPFA無法處理帶負環的圖）

 1 int spfa(int s)
 2 {
 3     queue<int> q;
 4     while(!q.empty())
 5         q.pop();
 6     q.push(s);
 7     dis[s]=1.0;
 8     vis[s]=1;
 9     num[s]++;
10     while(!q.empty()){
11         s=q.front();
12         q.pop();  
13         vis[s]=0;
14         for(int i=0; i<list[s].size(); i++){
15             int p=list[s][i];
16             if(dis[p]<dis[s]*mp[s][p]){
17                 dis[p]=dis[s]*mp[s][p];
18                 if(!vis[p]){
19                     vis[p]=1;
20                     q.push(p);
21                     num[p]++;
22                     if(num[p]==n)
23                         return 0;
24                 }
25             }
26         }
27     }
28     return 1;
29 }

 

 

 1 int spfa_bfs(int s)
 2 {
 3     queue <int> q;
 4     memset(d,0x3f,sizeof(d));
 5     d[s]=0;
 6     memset(c,0,sizeof(c));
 7     memset(vis,0,sizeof(vis));
 8 
 9     q.push(s);  vis[s]=1; c[s]=1;
10     //頂點入隊vis要做標記，另外要統計頂點的入隊次數
11     int OK=1;
12     while(!q.empty())
13     {
14         int x;
15         x=q.front(); q.pop();  vis[x]=0;
16         //隊頭元素出隊，並且消除標記
17         for(int k=f[x]; k!=0; k=nnext[k]) //遍歷頂點x的鄰接表
18         {
19             int y=v[k];
20             if( d[x]+w[k] < d[y])
21             {
22                 d[y]=d[x]+w[k];  //松弛
23                 if(!vis[y])  //頂點y不在隊內
24                 {
25                     vis[y]=1;    //標記
26                     c[y]++;      //統計次數
27                     q.push(y);   //入隊
28                     if(c[y]>NN)  //超過入隊次數上限，說明有負環
29                         return OK=0;
30                 }
31             }
32         }
33     }
34 
35     return OK;
36 
37 }

 

 

求多源、無負權邊的最短路:

Floyd算法

1.定義概覽

Floyd-Warshall算法（Floyd-Warshall algorithm）是解決任意兩點間的最短路徑的一種算法，可以正確處理有向圖或負權的最短路徑問題，同時也被用於計算有向圖的傳遞閉包。Floyd-Warshall算法的時間復雜度為O(N3)，空間復雜度為O(N2)。

 

2.算法描述

1)算法思想原理：

     Floyd算法是一個經典的動態規划算法。用通俗的語言來描述的話，首先我們的目標是尋找從點i到點j的最短路徑。從動態規划的角度看問題，我們需要為這個目標重新做一個詮釋（這個詮釋正是動態規划最富創造力的精華所在）

      從任意節點i到任意節點j的最短路徑不外乎2種可能，1是直接從i到j，2是從i經過若干個節點k到j。所以，我們假設Dis(i,j)為節點u到節點v的最短路徑的距離，對於每一個節點k，我們檢查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，證明從i到k再到j的路徑比i直接到j的路徑短，我們便設置Dis(i,j) = Dis(i,k) + Dis(k,j)，這樣一來，當我們遍歷完所有節點k，Dis(i,j)中記錄的便是i到j的最短路徑的距離。

2).算法描述：

a.從任意一條單邊路徑開始。所有兩點之間的距離是邊的權，如果兩點之間沒有邊相連，則權為無窮大。 　　

b.對於每一對頂點 u 和 v，看看是否存在一個頂點 w 使得從 u 到 w 再到 v 比己知的路徑更短。如果是更新它。

3).Floyd算法過程矩陣的計算----十字交叉法

 

代碼:

1 int d[MAX_V][MAX_V];  //d[u][v] 表示邊e=(u,v)的權值(不存在時設為INF,不過d[i][i]=0)
2 int v;
3 
4 void warshall_floyd(){ 5 for(int k=0; k<V; k++) 6 for(int i=0; i<V; i++) 7 for(int j=0; j<V; j++) 8 d[i][j]=min(d[i][j],d[i][k]+d[k][j]); 9 }

 

最小生成樹: 

Prim算法

1.概覽

普里姆算法（Prim算法），圖論中的一種算法，可在加權連通圖里搜索最小生成樹。意即由此算法搜索到的邊子集所構成的樹中，不但包括了連通圖里的所有頂點（英語：Vertex (graph theory)），且其所有邊的權值之和亦為最小。該算法於1930年由捷克數學家沃伊捷赫·亞爾尼克（英語：Vojtěch Jarník）發現；並在1957年由美國計算機科學家羅伯特·普里姆（英語：Robert C. Prim）獨立發現；1959年，艾茲格·迪科斯徹再次發現了該算法。因此，在某些場合，普里姆算法又被稱為DJP算法、亞爾尼克算法或普里姆－亞爾尼克算法。

給定一個無向圖,如果它的某個子圖中任意兩個頂點都互相連通並且是一棵樹,那么這課樹就叫做生成樹(Spanning Tree).如果邊上有權值,那么是的邊權和最小的生成樹叫做最小生成樹(MST,Minimum Spanning Tree) 

 

 

2.算法簡單描述

1).輸入：一個加權連通圖，其中頂點集合為V，邊集合為E；

2).初始化：Vnew = {x}，其中x為集合V中的任一節點（起始點），Enew = {},為空；

3).重復下列操作，直到Vnew = V：

a.在集合E中選取權值最小的邊<u, v>，其中u為集合Vnew中的元素，而v不在Vnew集合當中，並且v∈V（如果存在有多條滿足前述條件即具有相同權值的邊，則可任意選取其中之一）；

b.將v加入集合Vnew中，將<u, v>邊加入集合Enew中；

4).輸出：使用集合Vnew和Enew來描述所得到的最小生成樹。

 

 代碼:

 1 void prim()
 2 {
 3     memset(vis,0,sizeof(vis));
 4     memset(dis,INF,sizeof(dis)); 
 5     dis[1]=0;
 6     ans=0;
 7     dis[0]=INF;
 8     while(true){
 9         int m=0;
10         for(int i=1; i<=n; i++){
11             if(!vis[i] && dis[i]<dis[m])
12                 m=i;
13         }
14         if(m==0)
15             break;
16         vis[m]=1;
17         ans+=dis[m];
18         for(int i=1; i<=n; i++)
19             dis[i]=min(dis[i],mp[m][i]);
20     }
21 }

 

Kruskal算法

 

1.概覽

Kruskal算法是一種用來尋找最小生成樹的算法，由Joseph Kruskal在1956年發表。用來解決同樣問題的還有Prim算法和Boruvka算法等。三種算法都是貪婪算法的應用。和Boruvka算法不同的地方是，Kruskal算法在圖中存在相同權值的邊時也有效。

 

2.算法簡單描述

1).記Graph中有v個頂點，e個邊

2).新建圖Graphnew，Graphnew中擁有原圖中相同的e個頂點，但沒有邊

3).將原圖Graph中所有e個邊按權值從小到大排序

4).循環：從權值最小的邊開始遍歷每條邊 直至圖Graph中所有的節點都在同一個連通分量中

                if 這條邊連接的兩個節點於圖Graphnew中不在同一個連通分量中

                                         添加這條邊到圖Graphnew中

 

 

 1 struct edge{int u,v,cost;};
 2 
 3 bool cmp(edge &e1,const edge &e2){
 4     return e1.cost < e2.cost;
 5 }
 6 
 7 edge es[MAX_E];  
 8 int V,E;   //頂點數和邊數
 9 
10 int kruskal(){
11     sort(es,es+E,cmp);       //按照edge.cost的順序從小到大排列
12     init_union_find(V);      //並查集的初始化
13     int res=0;
14     for(int i=0; i<E; i++){
15         edge e=es[i];
16         if(!same(e.u,e.v)){
17             unite(e.u,e.v);
18             res+=e.cost;
19         }
20     }
21     return res;
22 }

 

 

 

 

 

 

 

 圖論所刷題目的鏈接:   http://www.cnblogs.com/qscqesze/p/4547000.html

 

 

參考書籍:<<挑戰程序設計競賽>>

參考博客:http://blog.csdn.net/yutianzuijin/article/details/11618651

            http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html

            http://www.cnblogs.com/biyeymyhjob/archive/2012/07/30/2615542.html

            http://www.cnblogs.com/scau20110726/archive/2012/11/18/2776124.html

            http://blog.csdn.net/v_july_v/article/details/6181485


免責聲明！

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



猜您在找 Bresenham算法理解 RSA算法理解 圖論算法總結 YOLOv1算法理解 EM算法理解的九層境界 最大流最小割 算法理解 【圖論】深入理解Dijsktra算法 關於SVM數學細節邏輯的個人理解（三） ：SMO算法理解 python-Kmeans\Kmeans++算法理解及代碼實現 Horn–Schunck 光流法與其算法理解（gup cuda）
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM