最小生成树之Kruskal算法

          给定一个无向图，如果它任意两个顶点都联通并且是一棵树，那么我们就称之为生成树(Spanning Tree)。如果是带权值的无向图，那么权值之和最小的生成树，我们就称之为最小生成树(MST, Minimum Spanning Tree)。

        我们由最小生成树的定义，可以延伸出一个修建道路的问题：把无向图的每个顶点看作村庄，计划修建道路使得可以在所有村庄之间通行。把每个村庄之间修建道路的费用看作权值，那么我们就可以得到一个求解修建道路的最小费用的问题。

        常见求解最小生成树的算法有Kruskal算法和Prim算法。由于篇幅问题再此对于Prim算法，就不多做解释了。现在我们看看Kruskal算法，是怎么来求解最小生成树的问题。

1、Kruskal算法描述

      Kruskal算法是基于贪心的思想得到的。首先我们把所有的边按照权值先从小到大排列，接着按照顺序选取每条边，如果这条边的两个端点不属于同一集合，那么就将它们合并，直到所有的点都属于同一个集合为止。至于怎么合并到一个集合，那么这里我们就可以用到一个工具——-并查集(不知道的同学请移步：Here)。换而言之，Kruskal算法就是基于并查集的贪心算法。

2、Kruskal算法流程

      对于图G(V,E)，以下是算法描述：

[cpp] view plain copy

print ?

1. 输入： 图G  
2. 输出： 图G的最小生成树  
3. 具体流程：  
4. (1)将图G看做一个森林，每个顶点为一棵独立的树  
5. (2)将所有的边加入集合S，即一开始S = E  
6. (3)从S中拿出一条最短的边(u,v)，如果(u,v)不在同一棵树内，则连接u,v合并这两棵树，同时将(u,v)加入生成树的边集E’  
7. (4)重复(3)直到所有点属于同一棵树，边集E’就是一棵最小生成树  

输入： 图G
输出： 图G的最小生成树
具体流程：
(1)将图G看做一个森林，每个顶点为一棵独立的树
(2)将所有的边加入集合S，即一开始S = E
(3)从S中拿出一条最短的边(u,v)，如果(u,v)不在同一棵树内，则连接u,v合并这两棵树，同时将(u,v)加入生成树的边集E'
(4)重复(3)直到所有点属于同一棵树，边集E'就是一棵最小生成树

      我们用现在来模拟一下Kruskal算法，下面给出一个无向图B,我们使用Kruskal来找无向图B的最小生成树。

 

        首先，我们将所有的边都进行从小到大的排序。排序之后根据贪心准则，我们选取最小边(A,D)。我们发现顶点A,D不在一棵树上，所以合并顶点A,D所在的树，并将边(A,D)加入边集E‘。

         我们接着在剩下的边中查找权值最小的边，于是我们找到的(C,E)。我们可以发现，顶点C,E仍然不在一棵树上，所以我们合并顶点C，E所在的树，并将边(C,E)加入边集E’

       不断重复上述的过程，于是我们就找到了无向图B的最小生成树，如下图所示：

3、Kruskal算法的时间复杂度

      Kruskal算法每次要从都要从剩余的边中选取一个最小的边。通常我们要先对边按权值从小到大排序，这一步的时间复杂度为为O(|Elog|E|)。Kruskal算法的实现通常使用并查集，来快速判断两个顶点是否属于同一个集合。最坏的情况可能要枚举完所有的边，此时要循环|E|次，所以这一步的时间复杂度为O(|E|α(V))，其中α为Ackermann函数，其增长非常慢，我们可以视为常数。所以Kruskal算法的时间复杂度为O(|Elog|E|)。

4、实战演练

      我们现在已经基本了解了Kruskal算法，让我们来一道题目练练手：畅通工程。这是一道非常基本的最小生成树的应用，所以我就不做详细说明了，这里仅附上代码以供参考：

[cpp] view plain copy

print ?

1. #include <cstdio>  
2. #include <cstdlib>  
3. #define MAXN 10000 + 10  
4. using namespace std;  
5.   
6. int par[MAXN], Rank[MAXN];  
7. typedef struct{  
8.     int a, b, price;  
9. }Node;  
10. Node a[MAXN];  
11.   
12. int cmp(const void*a, const void *b){  
13.     return ((Node*)a)->price - ((Node*)b)->price;  
14. }  
15. void Init(int n){  
16.     for(int i = 0; i < n; i++){  
17.         Rank[i] = 0;  
18.         par[i] = i;  
19.     }  
20. }  
21.   
22. int find(int x){  
23.     int root = x;  
24.     while(root != par[root]) root = par[root];  
25.     while(x != root){  
26.         int t = par[x];  
27.         par[x] = root;  
28.         x = t;  
29.     }  
30.     return root;  
31. }  
32.   
33. void unite(int x, int y){  
34.     x = find(x);  
35.     y = find(y);  
36.     if(Rank[x] < Rank[y]){  
37.         par[x] = y;  
38.     }  
39.     else{  
40.         par[y] = x;  
41.         if(Rank[x] == Rank[y]) Rank[x]++;  
42.     }  
43. }  
44. //n为边的数量，m为村庄的数量  
45. int Kruskal(int n, int m){  
46.     int nEdge = 0, res = 0;  
47.     //将边按照权值从小到大排序  
48.     qsort(a, n, sizeof(a[0]), cmp);  
49.     for(int i = 0; i < n && nEdge != m - 1; i++){  
50.         //判断当前这条边的两个端点是否属于同一棵树  
51.         if(find(a[i].a) != find(a[i].b)){  
52.             unite(a[i].a, a[i].b);  
53.             res += a[i].price;  
54.             nEdge++;  
55.         }  
56.     }  
57.     //如果加入边的数量小于m - 1,则表明该无向图不连通,等价于不存在最小生成树  
58.     if(nEdge < m-1) res = -1;  
59.     return res;  
60. }  
61. int main(){  
62.     int n, m, ans;  
63.     while(scanf(“%d%d”, &n, &m), n){  
64.         Init(m);  
65.         for(int i = 0; i < n; i++){  
66.             scanf(”%d%d%d”, &a[i].a, &a[i].b, &a[i].price);  
67.             //将村庄编号变为0~m-1（这个仅仅只是个人习惯，并非必要的）  
68.             a[i].a–;  
69.             a[i].b–;  
70.         }  
71.         ans = Kruskal(n, m);  
72.         if(ans == -1) printf(“?\n”);  
73.         else printf(“%d\n”, ans);  
74.     }  
75.     return 0;  
76. }  

#include <cstdio>

#include <cstdlib> #define MAXN 10000 + 10 using namespace std; int par[MAXN], Rank[MAXN]; typedef struct{ int a, b, price; }Node; Node a[MAXN]; int cmp(const void*a, const void *b){ return ((Node*)a)->price - ((Node*)b)->price; } void Init(int n){ for(int i = 0; i < n; i++){ Rank[i] = 0; par[i] = i; } } int find(int x){ int root = x; while(root != par[root]) root = par[root]; while(x != root){ int t = par[x]; par[x] = root; x = t; } return root; } void unite(int x, int y){ x = find(x); y = find(y); if(Rank[x] < Rank[y]){ par[x] = y; } else{ par[y] = x; if(Rank[x] == Rank[y]) Rank[x]++; } } //n为边的数量，m为村庄的数量 int Kruskal(int n, int m){ int nEdge = 0, res = 0; //将边按照权值从小到大排序 qsort(a, n, sizeof(a[0]), cmp); for(int i = 0; i < n && nEdge != m - 1; i++){ //判断当前这条边的两个端点是否属于同一棵树 if(find(a[i].a) != find(a[i].b)){ unite(a[i].a, a[i].b); res += a[i].price; nEdge++; } } //如果加入边的数量小于m - 1,则表明该无向图不连通,等价于不存在最小生成树 if(nEdge < m-1) res = -1; return res; } int main(){ int n, m, ans; while(scanf("%d%d", &n, &m), n){ Init(m); for(int i = 0; i < n; i++){ scanf("%d%d%d", &a[i].a, &a[i].b, &a[i].price); //将村庄编号变为0~m-1（这个仅仅只是个人习惯，并非必要的） a[i].a--; a[i].b--; } ans = Kruskal(n, m); if(ans == -1) printf("?\n"); else printf("%d\n", ans); } return 0; }

       当然要是觉得不够爽，那就再送大家一个大礼包：图论500题(这里包含了绝大多数的图论题目，对于每道题都有难度的注明)。



转载于:https://www.cnblogs.com/chuninggao/p/7295790.html