Kruskal算法

克鲁斯卡尔（Kruskal）算法（只与边相关）

算法描述：克鲁斯卡尔算法需要对图的边进行访问，所以克鲁斯卡尔算法的时间复杂度只和边又关系，可以证明其时间复杂度为O（eloge）。

算法过程：

1.将图各边按照权值进行排序

2.将图遍历一次，找出权值最小的边，（条件：此次找出的边不能和已加入最小生成树集合的边构成环），若符合条件，则加入最小生成树的集合中。不符合条件则继续遍历图，寻找下一个最小权值的边。

3.递归重复步骤1，直到找出n-1条边为止（设图有n个结点，则最小生成树的边数应为n-1条），算法结束。得到的就是此图的最小生成树。

克鲁斯卡尔（Kruskal）算法因为只与边相关，则适合求稀疏图的最小生成树。而prime算法因为只与顶点有关，所以适合求稠密图的最小生成树。

代码如下：

[cpp]  view plain copy

1. #include<iostream>  
2. #include<cstring>  
3. #include<string>  
4. #include<cstdio>  
5. #include<algorithm>  
6. using namespace std;  
7. #define MAX 1000  
8. int father[MAX], son[MAX];  
9. int v, l;  
10.   
11. typedef struct Kruskal //存储边的信息  
12. {  
13.     int a;  
14.     int b;  
15.     int value;  
16. };  
17.   
18. bool cmp(const Kruskal & a, const Kruskal & b)  
19. {  
20.     return a.value < b.value;  
21. }  
22.   
23. int unionsearch(int x) //查找根结点+路径压缩  
24. {  
25.     return x == father[x] ? x : unionsearch(father[x]);  
26. }  
27.   
28. bool join(int x, int y) //合并  
29. {  
30.     int root1, root2;  
31.     root1 = unionsearch(x);  
32.     root2 = unionsearch(y);  
33.     if(root1 == root2) //为环  
34.         return false;  
35.     else if(son[root1] >= son[root2])  
36.         {  
37.             father[root2] = root1;  
38.             son[root1] += son[root2];  
39.         }  
40.         else  
41.         {  
42.             father[root1] = root2;  
43.             son[root2] += son[root1];  
44.         }  
45.     return true;  
46. }  
47.   
48. int main()  
49. {  
50.     int ncase, ltotal, sum, flag;  
51.     Kruskal edge[MAX];  
52.     scanf("%d", &ncase);  
53.     while(ncase--)  
54.     {  
55.         scanf("%d%d", &v, &l);  
56.         ltotal = 0, sum = 0, flag = 0;  
57.         for(int i = 1; i <= v; ++i) //初始化  
58.         {  
59.             father[i] = i;  
60.             son[i] = 1;  
61.         }  
62.         for(int i = 1; i <= l ; ++i)  
63.         {  
64.             scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].value);  
65.         }  
66.         sort(edge + 1, edge + 1 + l, cmp); //按权值由小到大排序  
67.         for(int i = 1; i <= l; ++i)  
68.         {  
69.             if(join(edge[i].a, edge[i].b))  
70.             {  
71.                 ltotal++; //边数加1  
72.                 sum += edge[i].value; //记录权值之和  
73.                 cout<<edge[i].a<<"->"<<edge[i].b<<endl;  
74.             }  
75.             if(ltotal == v - 1) //最小生成树条件：边数=顶点数-1  
76.             {  
77.                 flag = 1;  
78.                 break;  
79.             }  
80.         }  
81.         if(flag) printf("%d\n", sum);  
82.         else printf("data error.\n");  
83.     }  
84.     return 0;  
85. }