POJ 1861 Network (模版kruskal算法)

Network
Time Limit: 1000MS        Memory Limit: 30000K
Total Submissions:         Accepted:         Special Judge
Description

Andrew is working as system administrator and is planning to establish a new network in his company. There will be N hubs in the company, they can be connected to each other using cables. Since each worker of the company must have access to the whole network, each hub must be accessible by cables from any other hub (with possibly some intermediate hubs).
Since cables of different types are available and shorter ones are cheaper, it is necessary to make such a plan of hub connection, that the maximum length of a single cable is minimal. There is another problem — not each hub can be connected to any other one because of compatibility problems and building geometry limitations. Of course, Andrew will provide you all necessary information about possible hub connections.
You are to help Andrew to find the way to connect hubs so that all above conditions are satisfied.
Input

The first line of the input contains two integer numbers: N - the number of hubs in the network ( <= N <= ) and M - the number of possible hub connections ( <= M <= ). All hubs are numbered from  to N. The following M lines contain information about possible connections - the numbers of two hubs, which can be connected and the cable length required to connect them. Length is a positive integer number that does not exceed . There will be no more than one way to connect two hubs. A hub cannot be connected to itself. There will always be at least one way to connect all hubs.
Output

Output first the maximum length of a single cable in your hub connection plan (the value you should minimize). Then output your plan: first output P - the number of cables used, then output P pairs of integer numbers - numbers of hubs connected by the corresponding cable. Separate numbers by spaces and/or line breaks.
Sample Input

Sample Output

View Question

代码WA了，待查找原因

 #include<iostream>
 #include<cstring>
 #include<string>
 #include<cstdio>
 #include<algorithm>
 using namespace std;
 #define MAX 1000
 int father[MAX], son[MAX], Min=0x3fffffff;
 int v, l;

 typedef struct Kruskal //存储边的信息
 {
     int a;
     int b;
     int value;
 };

 bool cmp(const Kruskal & a, const Kruskal & b)
 {
     return a.value < b.value;
 }

 int unionsearch(int x) //查找根结点+路径压缩
 {
     return x == father[x] ? x : unionsearch(father[x]);
 }

 bool join(int x, int y) //合并
 {
     int root1, root2;
     root1 = unionsearch(x);
     root2 = unionsearch(y);
     if(root1 == root2) //为环
         return false;
     else if(son[root1] >= son[root2])
         {
             father[root2] = root1;
             son[root1] += son[root2];
         }
         else
         {
             father[root1] = root2;
             son[root2] += son[root1];
         }
     return true;
 }

 int main()
 {
     int ltotal;
     int res_f[],res_b[];
     Kruskal edge[MAX];
     while(scanf("%d%d",&v,&l)!=EOF)
     {
         ltotal = ;
         for(int i = ; i <= v; ++i) //初始化
         {
             father[i] = i;
             son[i] = ;
         }
         for(int i = ; i <= l ; ++i)
         {
             scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].value);
         }
         sort(edge + , edge +  + l, cmp); //按权值由小到大排序
         for(int i = ; i <= l; ++i)
         {
             if(join(edge[i].a, edge[i].b))
             {
                 res_f[ltotal]=edge[i].a; res_b[ltotal]=edge[i].b;
                 ltotal++; //边数加1
                 //cout<<edge[i].a<<" "<<edge[i].b<<endl;
                 if(edge[i].value < Min)
                     Min=edge[i].value;
             }
         }
         printf("%d\n%d\n",Min,ltotal);
         for(int i=;i<ltotal;i++){
             printf("%d %d\n",res_f[i],res_b[i]);
         }
     }
     return ;
 }

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

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

算法过程：

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

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

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

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

摘自http://blog.csdn.net/niushuai666/article/details/6689285

AC代码：

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <iostream>
 #include <malloc.h>
 #include <algorithm>
 #define MAX 10500
 #define INF 0x3FFFFFFF
 using namespace std;
 int par[MAX],n,m,maxedge,cnt;
 struct Edge{
     int s,e;
     int value;
 }edge[MAX],index[MAX];

 bool cmp(Edge a, Edge b){
     return a.value < b.value;
 }

 int find(int x){
     while(par[x] != x)
         x = par[x];
     return x;
 }

 void connect(int a,int b){
     if(a < b)
         par[b] = a;
     else
         par[a] = b;
 }

 void kruskal(){
     int i,j;
     maxedge = ;
     cnt = ;
     for(i=; i<=m; i++)
     {
         int a = find(edge[i].s);
         int b = find(edge[i].e);
         if(a != b)
         {
             connect(a,b);
             if(maxedge < edge[i].value);
                 maxedge = edge[i].value;
             cnt ++;
             index[cnt].s = edge[i].s;
             index[cnt].e = edge[i].e;
         }
         if(cnt >= n-)
             break;
     }
 }
 int main(){
    int i,j;
    while(scanf("%d%d",&n,&m) != EOF){
        for(i=; i<=m; i++){
            scanf("%d%d%d",&edge[i].s,&edge[i].e,&edge[i].value);
        }

        sort(edge+,edge++m,cmp);

        for(i=; i<=n; i++){
            par[i] = i;
        }
        memset(index,,sizeof(index));
        kruskal();
        printf("%d\n%d\n",maxedge,cnt);

        for(i=; i<=cnt; i++){
            printf("%d %d\n",index[i].s,index[i].e);
        }
    }
    return ;
 }