最小生成树的3个算法

最小生成树——Prim、Kruskal、Sollin(Boruvka)

 

本文内容框架：

1.Prim算法及其基于优先队列实现

      2.Kruskal算法

      3.Sollin算法

对于最小生成树，有两种算法可以解决。一种是Prim算法，该算法的时间复杂度为O(n²)，与图中边数无关，该算法适合于稠密图，而另外一种是Kruskal，该算法的时间主要取决于边数，它较适合于稀疏图。

 

Prim算法

 

Prim算法描述

 

设图G =（V，E），其生成树的顶点集合为U。

①、把v0放入U。

②、在所有u∈U，v∈V-U的边(u，v)∈E中找一条最小权值的边，加入生成树。

③、把②找到的边的v加入U集合。如果U集合已有n个元素，则结束，否则继续执行②。

时间复杂度

 

最小边、权的数据结构 时间复杂度（总计）

邻接矩阵、搜索	O(V2)
二叉堆（后文伪代码中使用的数据结构）、邻接表	O((V + E) log(V)) = O(E log(V))
斐波那契堆、邻接表	O(E + V log(V))

（该图转自wikipedia）

 

通过邻接矩阵图表示的简易实现中，找到所有最小权边共需O（V²）的运行时间。使用简单的二叉堆与邻接表来表示的话，普里姆算法的运行时间则可缩减为O(E *log V)，其中E为连通图的边数，V为顶点数。如果使用较为复杂的斐波那契堆，则可将运行时间进一步缩短为O(E + V* log V)，这在连通图足够密集时（当E满足Ω（V* log V）条件时），可较显著地提高运行速度。

 

Prim算法实现

用优先队列实现

 

Cpp代码  

1. #include <iostream>    
2. #include <cstdio>    
3. #include <cstdlib>    
4. #include <cstring>    
5. #include <cmath>    
6. #include <algorithm>    
7. #include <set>    
8. #include <map>    
9. #include <vector>    
10. #include <queue>    
11. #include <ctime>    
12. using namespace std;    
13. #define LL long long    
14. const int N = 2000;    
15. const int INF = 1 << 30;    
16.     
17. struct Node    
18. {    
19.     int v,next,w;    
20.     bool operator < (const Node &a) const    
21.     {    
22.         return w > a.w;    
23.     }    
24. } p[N],t1,t2;    
25.     
26. int dis[N],vis[N],head[N],cnt;    
27. int res;    
28.     
29. void addedge(int u,int v,int w)    
30. {    
31.     p[cnt].v = v;    
32.     p[cnt].next = head[u];    
33.     p[cnt].w = w;    
34.     head[u] = cnt++;    
35. }    
36.     
37. void prim()    
38. {    
39.     priority_queue<Node> q;    
40.     for(int i = head[0] ; i != -1 ; i = p[i].next)    
41.     {    
42.         int v = p[i].v;    
43.         if(p[i].w < dis[v])    
44.         {    
45.             dis[v] = p[i].w;    
46.             t1.w = dis[v];    
47.             t1.v =  v;    
48.             q.push(t1);    
49.         }    
50.     }    
51.     vis[0] = 1;    
52.     while(!q.empty())    
53.     {    
54.         t1 = q.top();    
55.         q.pop();    
56.         int u = t1.v;    
57.         if(vis[u]) continue;    
58.         vis[u] = 1;    
59.         res += dis[u];    
60.         for(int i = head[u]; i != -1; i = p[i].next)    
61.         {    
62.             int v = p[i].v;    
63.             if(!vis[v] && dis[v] > p[i].w)    
64.             {    
65.                 dis[v] = p[i].w;    
66.                 t2.v = v;    
67.                 t2.w = dis[v];    
68.                 q.push(t2);    
69.             }    
70.         }    
71.     }    
72. }    
73.     
74. int main()    
75. {    
76.     int n,m,w;    
77.     while(scanf("%d",&n),n)    
78.     {    
79.         memset(p,0,sizeof(p));    
80.         memset(head,-1,sizeof(head));    
81.         memset(vis,0,sizeof(vis));    
82.         char u,v;    
83.         for(int i=0; i<n-1; i++)    
84.         {    
85.             cin>>u>>m;    
86.             for(int j=0; j<m; j++)    
87.             {    
88.                 cin>>v>>w;    
89.                 addedge(u-'A',v-'A',w);    
90.                 addedge(v-'A',u-'A',w);    
91.             }    
92.         }    
93.         for(int i = 0 ; i < n ;  i ++) dis[i] = INF;    
94.         res = 0;    
95.         prim();    
96.         printf("%d\n",res);    
97.     }    
98.     return 0;    
99. }    

 

转自http://blog.youkuaiyun.com/acceptedxukai/article/details/6978868

 

Kruskal算法

  Kruskal算法与Prim算法的不同之处在于，Kruskal在找最小生成树结点之前，需要对所有权重边做从小到大排序。将排序好的权重边依次加入到最小生成树中，如果加入时产生回路就跳过这条边，加入下一条边。当所有结点都加入到最小生成树中之后，就找出了最小生成树。

Kruskal算法步骤

1.新建图G，G中拥有原图中相同的点，但没有边

2.将原图中所有的边按权值从小到大排序

3.从权值最小的边开始，如果这条边链接的两个点于图G中不在同一个连通分量中，则添加这条边到图G中

4.重复3，直至图G中所有的点都在同一个连通分量中

Kruskal算法实现

利用最小堆来存储边集E，利用并-查集来判断向T中添加边是否构成环路。

Cpp代码  

1. #include <iostream>  
2. #include <vector>  
3. #include <algorithm>  
4. using namespace std;  
5.    
6. struct Edge   
7. {  
8.     int from, to, w; //~ 不要被假象迷惑，这里是无向图  
9.     Edge(int f, int t, int _w): from(f), to(t), w(_w){}  
10.     /* 
11.     //~ bool operator <(const Edge& e){ return w < e.w; } 
12.     bool operator >(const Edge& e){ return w > e.w; } 
13.     */  
14. };  
15. //~ 为什么我把operator<重载为成员会出错？  
16. //~ bool operator <(const Edge& e1, const Edge& e2){ return e1.w < e2.w; }  
17. bool operator >(const Edge& e1, const Edge& e2){ return e1.w > e2.w; }   
18. bool AddEdge(vector<int> & V, const Edge& e);  
19. int main(int argc, char* argv[])  
20. {  
21.     vector<Edge> E;  
22.     int from, to, w;  
23.     int n; //~ 顶点数  
24.     cin>>n;  
25.     vector<int> V(n+1, -1); //~ 顶点并查集  
26.     while (cin>>from>>to>>w) E.push_back(Edge(from, to, w));  
27.    
28.     make_heap(E.begin(), E.end(), greater<Edge>());  
29.     int count = 0; //~ 已添加边数  
30.     while (E.size())  
31.     {  
32.         Edge e = E[0];  
33.         if(AddEdge(V, e)) //~ 将成功添加的边输出  
34.         {  
35.             count++;  
36.             if(count == n - 1) break; //~ 树已生成完毕  
37.             cout<<e.from<<"->"<<e.to<<": "<<e.w<<endl;  
38.         }  
39.         pop_heap(E.begin(), E.end(),greater<Edge>());  
40.         E.pop_back();  
41.     }  
42.     if (count != n - 1) cout<<"I cannot do what you want."<<endl;  
43.     return 0;  
44. }  
45.    
46. bool AddEdge(vector<int> & V, const Edge& e)  
47. {  
48.     int i = e.from;  
49.     for (; V[i] > 0;) i = V[i]; //~ 寻找根节点  
50.     int j = e.to;  
51.     for (; V[j] > 0;) j = V[j]; //~ 寻找根节点  
52.     if (i == j)    return false; //~ i,j两节点已经联通  
53.     if (V[i] > V[j]) //~ 将小集合合并至大集合上  
54.         V[i] = j;  
55.     else  
56.         V[j] = i;  
57.     return true; //~ ^_^  

 转自http://www.cppblog.com/superKiki/archive/2010/05/02/114180.aspx

 

Sollin（Boruvka)算法

Sollin（Brouvka)算法虽然是最小生成树最古老的一个算法之一，其实是前面介绍两种算法的综合，每次迭代同时扩展多课子树，直到得到最小生成树T。

Sollin（Boruvka)算法步骤

1.用定点数组记录每个子树（一开始是单个定点）的最近邻居。（类似Prim算法)

2.对于每一条边进行处理（类似Kruskal算法）

如果这条边连成的两个顶点同属于一个集合，则不处理，否则检测这条边连接的两个子树，如果是连接这两个子树的最小边，则更新(合并)

 

由于每次循环迭代时，每棵树都会合并成一棵较大的子树，因此每次循环迭代都会使子树的数量至少减少一半，或者说第i次迭代每个分量大小至少为。所以，循环迭代的总次数为O(logn)。每次循环迭代所需要的计算时间：对于第2步，每次检查所有边O(m)，去更新每个连通分量的最小弧；对于第3步，合并个子树。所以总的复杂度为O(E*logV)。

Sollin(Boruvka)算法实现

 

C代码  

1. typedef struct{int v;int w;double wt;}Edge;  
2. typeder struct{int V;int E;double **adj}Graph;  
3. /*nn存储每个分量的最邻近，a存储尚未删除且还没在MST中的边 
4. *h用于访问要检查的下一条边 
5. *N用于存放下一步所保存的边 
6. *每一步都对应着检查剩余的边，连接不同分量的顶点的边被保留在下一步中 
7. *最后每一步将每个分量与它最邻近的分量合并，并将最近邻边添加到MST中 
8. */  
9. Edge nn[maxE],a[maxE];  
10. void Boruvka(Graph g,Edge mst[])  
11. {  
12. int h,i,j,k,v,w,N;  
13. Edge e;  
14. int E=GRAPHedges(a,G);  
15. for(UFinit(G->V);E!=0;E=N)  
16. {  
17.      for(k=0;k<G->V;k++)  
18.            nn[k]=Edge(G->V,G->V,maxWT);  
19.      for(h=0,N=0;h<E;h++)  
20.      {  
21.           i=find(a[h].v);j=find(a[h].w);  
22.           if(i==h) continue;  
23.           if(a[h].wt<nn[i].wt)nn[i]=a[h];  
24.           if(a[h].wt<nn[j].wt)nn[j]=a[h];  
25.           a[N++]=a[h];  
26.       }  
27.       for(k=0;k<G->V;k++)  
28.       {  
29.            e=nn[k];v=e.v;w=e.w;  
30.            if(v!=G->V&&!UFfind(v,w))  
31.            {  
32.                 UFunion(v,w);mst[k]=e;  
33.              }  
34.         }  
35.   
36. }  

转自 http://dsqiu.iteye.com/blog/1689178