最小生成树，转别人的

最小生成树即最小权重生成树，主要适用于 N个点之间 构造N-1线路，使N个点之间任意两点之间都可到达，
但是N个点之间 不构成回路，并且这N-1条线路的权重之和最小即 消耗最小。

注意：在构造最小生成树，加入新的节点时，不仅要保证权重最小，首要条件是 不能构成回路。

以图示为例，构造最小生成树

（一）普里姆   以下步骤

（二） 克鲁斯卡尔 最终的最小生成树 和 普里姆一样  

   一、普里姆算法  
       
       思想：取图中任意一点，以确定当前点所连接所有点的权重中最小的点来加入最小生成树，再以新加入

的点，来继续确定剩余点到当前点的权重最小加入最小生成树

时间复杂度：O(n*n)

适应范围   :  稠密图

[html]  view plain copy

1. const int N = 65535;  
2. int map[1000][1000];  
3. int vis[1000],dis[1000];  
4. void prim()  
5. {  
6.      
7.     int ans=0;  
8.     int i,j;  
9.     memset(vis,0,sizeof(vis)); //标记是否被访问的数组，初始化  
10.     memset(dis,0,sizeof(dis));  
11.     for(i = 1; i <= n; i++)  
12.         dis[i] = map[1][i];    //dis[]保存到最小生成树的最短距离  
13.     vis[1] = 1; //标记1顶点已加入最小生成树  
14.     for(i = 1; i <= n-1; i++)  
15.     {  
16.         int pos;//寻找一个未被加入生成树的点，满足它到生成树的距离最短  
17.         int min; //保存这个最短距离  
18.         min = N;  
19.         for(j = 1; j <= n; j++)  
20.         {  
21.             if(vis[j]==0&&min>dis[j])  
22.             {  
23.                 pos=j;  
24.                 min=dis[j];  
25.             }  
26.         }  
27.          if(min==N)  
28.          {  
29.            printf("?\n");//如果没有点相连，打印问号  
30.             return ;  
31.          }  
32.         vis[pos]  = 1; //标记已加入最小生成树集合...  
33.         ans += min;    //权值加上那个最短距离  
34.         for(j = 1; j <= n; j++) //松弛，因为pos的加入，其他点到最小生成树的//距可能减小  
35.         {  
36.             if(vis[j]==0 && dis[j]>map[pos][j])  
37.                 dis[j]=map[pos][j];  
38.         }  
39.     }  
40.      printf("%d\n",ans);  
41.         return ;  
42. }  

   二、克鲁斯卡尔
     
       思想：以确定边来构造最小生成树，当然克鲁斯卡尔应用的是贪心思想+并查集，按权值递增顺序删去图中的边，

若不形成回路则将此边加入最小生成树

时间复杂度 :   O(e*loge)

适应范围   ：   稀疏图

具体操作：  1。并查集  查边2、将权重 排序，3、构造最小生成树

事例代码：

         n个城市，m条线路，修建n-1 条路使任意一点都可以到达所有城市，并且话费最少

[html]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <iostream>  
4. #include <string.h>  
5. const int N = 65535;  
6. using namespace std;  
7. struct node{  
8.     int u,w,v;  
9. }edge[10001];  
10. int father[1001],n,m,ans;  
11. int cmp(const void *a,const void *b)  
12. {  
13.     node *X,*Y;  
14.     X = (struct node *)a;  
15.     Y = (struct node *)b;  
16.   
17.     return X->w - Y->w ;  
18. }  
19. int findx(int r)  
20. {  
21.     return (father[r]==r)?r:findx(father[r]);  
22. }  
23. /*int findx(int r)//2查找 压缩路径  
24. {  
25.   
26.     while(r!=father[r])  
27.     {  
28.          r = father[r];  
29.     }  
30.     int i = r,j;  
31.     while(father[i]!=r)  
32.     {  
33.         j = father[i];  
34.         father[i] = r;  
35.         i = j;  
36.     }  
37.     return r;  
38. }*/  
39.   
40. void init()  
41. {  
42.     for(int i = 1; i <= n; i++)  
43.         father[i] = i;  //每个节点初始化自成一个集合  
44. }  
45. void kruskal()  
46. {  
47.     init();  
48.     for(int i = 0; i < m; i++)   //按边的权值大小加边  
49.     {  
50.         //找当前点到最小生成树的最短边  
51.         int uu = findx(edge[i].u);  
52.         int vv = findx(edge[i].v);  
53.         if(uu != vv)  
54.         {  
55.             father[uu] = vv;  
56.             ans += edge[i].w;  
57.         }  
58.     }  
59. }  
60. int main()  
61. {  
62.     while(scanf("%d%d",&n,&m)!=EOF)  
63.     {  
64.         ans = 0;  
65.         for(int i =0;i<m;i++)  
66.         {  
67.             scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);  
68.         }  
69.   
70.         qsort(edge,m,sizeof(edge[0]),cmp);//升序排序  
71.         kruskal();  
72.   
73.         printf("%d\n",ans);  
74.     }  
75.     return 0;  
76. }