(ZJU-2006复试)-HDOJ-1233-还是畅通工程

还是畅通工程

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 4404    Accepted Submission(s): 2099

Problem Description

某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

 

Input

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。

 

Output

对每个测试用例，在1行里输出最小的公路总长度。

 

Sample Input

3
1 2 1
1 3 2
2 3 4
4
1 2 1
1 3 4
1 4 1
2 3 3
2 4 2
3 4 5
0

 

Sample Output

3
5


  
  

   
   

    
    Hint
   
   
Hint
  
  
 
Huge input, scanf is recommended.

比1232畅通工程更标准的最小生成树

并查集+kruskal

#include <iostream>
#include <algorithm>
using namespace std;
int c[101];
int size[101];
struct node_typ
{
    int a;
    int b;
    int dist;
};
node_typ node[4951];

int mindistance=0;

bool cmp(const node_typ a, const node_typ b)
{
    return a.dist<b.dist;
}

int find(int x)
{
    if(c[x]==x)return x;
    else return (c[x]=find(c[x]));
}

void combine(int a, int b)
{
    if(size[a]>size[b])
    {
        c[b]=a;
        size[a]+=size[b];
    }
    else
    {
        c[a]=b;
        size[b]+=size[a];
    }
}

int main()
{
    int n;
    while(cin>>n&&n)
    {
        for(int i=0;i<n*(n-1)/2;++i)
        {   
            int a,b; 
            cin>>a>>b>>node[i].dist;
            node[i].a=a-1;
            node[i].b=b-1;
        }
        for(int i=0;i<n;++i)
        {
            c[i]=i;
            size[i]=1;
        }
        
        sort(node, node+n*(n-1)/2, cmp);
        
        mindistance=0;
        for(int i=0;i<n*(n-1)/2;++i)
        {
            if(node[i].dist!=0)
            {
                int ka=find(node[i].a);
                int kb=find(node[i].b);
                if(ka!=kb)
                {       
                    combine(ka,kb);
                    mindistance+=node[i].dist;
                } 
            }  
        }   
        cout<<mindistance<<endl;
    }
    return 0;
}

/*--------------------------------------------------------------------------------------------------*/

PRIM算法

#include <iostream>

using namespace std;

#define INF 999999

int closedge[101];

int map[101][101];

int used[101];

int main()

{

    int n;

    while(cin>>n&&n)

    {

        for(int i=0;i<101;++i)

            for(int j=0;j<101;++j)

                map[i][j]=INF;

                

        for(int i=0;i<n*(n-1)/2;++i)

        {

            int a,b,d;

            cin>>a>>b>>d;

            if(d)

                map[a-1][b-1]=map[b-1][a-1]=d; 

        }

        

        closedge[0]=0;used[0]=1;  //选第一个点作为起始点 

        for(int i=1;i<n;++i)

        {

            closedge[i]=map[0][i];   //初始化 

            used[i]=0;

        }

        

        

        int mindistance=0;

        for(int i=1;i<n;++i)

        {

            int min=INF,minj=0;

            for(int j=1;j<n;++j)    //每次选择离已选集合距离最短的点 

            {

                if(!used[j]&&min>closedge[j])

                    min=closedge[j],minj=j;

            }

            

            used[minj]=1;closedge[minj]=0;  //将这个点加入集合 

            

            if(min!=INF) 

                mindistance+=min;

                

            for(int j=1;j<n;++j)

            {

                if(map[minj][j]<closedge[j])    //更新closedge 

                    closedge[j]=map[minj][j];

            }

                

        }

        cout<<mindistance<<endl;

    }

    return 0;

}