Kruskal算法（贪心+并查集=最小生成树）

http://www.51nod.com/

Kruskal算法（克鲁斯卡尔算法）的高效实现需要一种称作并查集的结构。我们在这里不介绍并查集，只介绍Kruskal算法的基本思想和证明，实现留在以后讨论。

Kruskal算法的过程：

（1） 将全部边按照权值由小到大排序。
（2） 按顺序（边权由小到大的顺序）考虑每条边，只要这条边和我们已经选择的边不构成圈，就保留这条边，否则放弃这条边。

算法 成功选择(n-1)条边后，形成一个棵最小生成树，当然如果算法无法选择出(n-1)条边，则 说明原图不连通。

以下图为例：

边排序后为：

1　AF 1

2　DE 4

3　BD 5

4　BC 6

5　CD 10

6　BF 11

7　DF 14

8　AE 16

9　AB 17

10　EF 33

算法处理过程如下：

处理边AF，点A与点F不在同一个集合里，选中AF。

处理边DE，点D与点E不在同一个集合里，选中DE

处理边BD，点B与点D不在同一个集合里，选中BD

处理边BC，点B与点C不在同一个集合里，选中BC

处理边CD，点C与点D在同一个集合里，放弃CD。

处理边BF，点B与点F不在同一个集合里，选中BF。

至此，所有的点都连在了一起，剩下的边DF，AE，AB，EF不用继续处理了，算法执行结束。

Kruskal算法的证明。假设图连通，我们证明Krusal算法得到一棵最小生成树。我们假设Kruskal算法得到的树是K (注意我们已经假设Kruskal算法一定可以得到生成树)。假设T是一棵最小生成树，并且K ≠T, K中显然至少有一条边。我们找到在K中，而不在T中最小权值的边e。

把e加入T中，则形成一个圈，删掉这个圈中不在K中的边f,得到新的生成树T’。
f的存在性，如果全里面所有的边都在K中，则K包含圈，矛盾。

考虑边权值关系：

（1） 若w(f) > w(e), 则T’的权值和小于T的权值和，与T是最小生成树矛盾。
（2） 若w(f) < w(e), 说明Kruskal算法在考虑加入e之前先考虑了边f，之所以没加入f是因为f和之前加入的边形成圈，之前加入的边权值显然不超过w(f) (因为加边是从小到大的顺序加入的)，所以之前加入的边权值一定小于w(e)。而根据e的定义，K中权值小于w(e)的边都在T中，这说明T中的边会和f构成圈，矛盾。

所以只能w(f) = w(e)。T’仍然是最小生成树，而T’和K相同的边多了一条。
这样下去有限步之后，最终可以把T变为K，从而K也是最小生成树。

最后，我们来提供输入输出数据，由你来写一段程序，实现这个算法，只有写出了正确的程序，才能继续后面的课程。

输入

第1行：2个数N,M中间用空格分隔，N为点的数量，M为边的数量。（2 <= N <= 1000, 1 <= M <= 50000)
第2 - M + 1行：每行3个数S E W，分别表示M条边的2个顶点及权值。(1 <= S, E <= N，1 <= W <= 10000)

输出

输出最小生成树的所有边的权值之和。

输入示例

9 14
1 2 4
2 3 8
3 4 7
4 5 9
5 6 10
6 7 2
7 8 1
8 9 7
2 8 11
3 9 2
7 9 6
3 6 4
4 6 14
1 8 8

输出示例

37

请选取你熟悉的语言，并在下面的代码框中完成你的程序，注意数据范围，最终结果会造成Int32溢出，这样会输出错误的答案。

不同语言如何处理输入输出，请查看下面的语言说明。

使用并查集和贪心思想。适合稀疏图。

Kruskal算法实现：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. using namespace std;  
5. int parent[10];  
6. int n,m;  
7. int i,j;  
8.   
9. struct edge{  
10.     int u,v,w; //边的顶点，权值  
11. }edges[10];  
12.   
13. //初始化并查集  
14. void UFset(){  
15.     for(i=1; i<=n; i++) parent[i] = -1;  
16. }  
17.   
18. //查找i的跟  
19. int find(int i){  
20.     int temp;  
21.     //查找位置  
22.     for(temp = i; parent[temp] >= 0; temp = parent[temp]);  
23.     //压缩路径  
24.     while(temp != i){  
25.         int t = parent[i];  
26.         parent[i] = temp;  
27.         i = t;  
28.     }  
29.     return temp;  
30. }  
31. //合并两个元素a,b  
32. void merge(int a,int b){  
33.     int r1 = find(a);  
34.     int r2 = find(b);  
35.     int tmp = parent[r1] + parent[r2]; //两个集合节点数的和  
36.     if(parent[r1] > parent[r2]){  
37.         parent[r1] = r2;  
38.         parent[r2] = tmp;  
39.     }else{  
40.         parent[r2] = r1;  
41.         parent[r1] = tmp;  
42.     }  
43. }  
44.   
45. void kruskal(){  
46.     int sumWeight = 0;  
47.     int num = 0;  
48.     int u,v;  
49.     UFset();  
50.     for(int i=0; i<m; i++)  
51.     {  
52.         u = edges[i].u;  
53.         v = edges[i].v;  
54.   
55.         if(find(u) != find(v)){ //u和v不在一个集合  
56.             printf("加入边：%d %d,权值： %d\n", u,v,edges[i].w);  
57.             sumWeight += edges[i].w;  
58.             num ++;  
59.             merge(u, v); //把这两个边加入一个集合。  
60.         }  
61.     }  
62.     printf("weight of MST is %d \n", sumWeight);  
63. }  
64.   
65. //比较函数，用户排序  
66. int cmp(const void * a, const void * b){  
67.     edge * e1 = (edge *)a;  
68.     edge * e2 = (edge *)b;  
69.     return e1->w - e2->w;  
70. }  
71.   
72. int main() {  
73.   
74.     scanf("%d %d", &n, &m);  
75.     for(i=0; i<m; i++){  
76.         scanf("%d %d %d", &edges[i].u,  &edges[i].v,  &edges[i].w);  
77.     }  
78.     qsort(edges, m, sizeof(edge), cmp);  
79.   
80.     kruskal();  
81.   
82.   
83.     return 0;  
84. }  
85. /* 
86. 测试数据： 
87. 7 9 
88. 1 2 28 
89. 1 6 10 
90. 2 3 16 
91. 2 7 14 
92. 3 4 12 
93. 4 5 22 
94. 4 7 18 
95. 5 6 25 
96. 5 7 24 
97. 输出： 
98. 加入边：1 6,权值： 10 
99. 加入边：3 4,权值： 12 
100. 加入边：2 7,权值： 14 
101. 加入边：2 3,权值： 16 
102. 加入边：4 5,权值： 22 
103. 加入边：5 6,权值： 25 
104. weight of MST is 99   */