最小生成树问题

hdu 1233

 

还是畅通工程

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

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.

 

 

本题只需构造一棵最小生成树即可。

根据普里姆算法：

    先找到最短的路径，将路径以及端点都标识为已访问。

    在比较已访问的端点与未访问的端点间的路径，将其中最大的边提取出，并将边和端点标识。

    重复以上做法，直到所有的端点都被访问。

 

 

代码：

#include<iostream>
#include<stdio.h>
using namespace std;
int a[102][102];                 //存放两端点间的长度
int b[102][102];                    //表示端点间的路径是否已被访问
int way[102];                      //表示端点是否已被访问
int main(){ 
    int sum=0;
    int times=0;
    int n;
    while(cin>>n){
           if(n==0)
               break;
           if(n==1){
               cout<<"0"<<endl;
               continue;
               }
           sum=0;
           times=0;
           int a1,a2;
        //   memset(a,0,sizeof(a));
           memset(b,0,sizeof(b));
           memset(way,0,sizeof(way));
           for(int i=1;i<=(n*(n-1))/2;i++){
                   scanf("%d%d ",&a1,&a2);
                  // cin>>a1>>a2;
                 scanf("%d",&a[a1][a2]);
                  // cin>>a[a1][a2];
                           }
           int min=100000;
           for(int h=1;h<=n*(n-1)/2;h++){
                   for(int g=h+1;g<=n;g++){
                           if(a[h][g]<=min){
                                  min=a[h][g];
                                  a1=h;
                                  a2=g;
                                  }
                                  }
                                  }
           b[a1][a2]=1;
           sum+=min;
           times=1;
           way[a1]=1;
           way[a2]=1;
      //     cout<<sum<<endl;
           while(times<n-1){
               min=1000000;
               int flag=0;
               for(int k=1;k<=n*(n-1)/2;k++){
          //             if(way[k]==1){
                       for(int f=k+1;f<=n;f++){
                        //       cout<<way[k]<<" "<<way[f]<<endl;
                               if(way[k]+way[f]==1){                         //只能够找有一个顶点在最短路径集合中的边
                               if(b[k][f]==0&&(min>a[k][f])){
                                       min=a[k][f];
                                       a1=k;
                                       a2=f;
                                       flag=1;
                                       }
                                       }
                                       }
                                       }
               if(flag==1){
               b[a1][a2]=1;
           //    cout<<a1<<" "<<a2<<" "<<min<<endl;
               way[a1]=1;
               way[a2]=1;
               sum+=min;
               times++;
               }
               }
           cout<<sum<<endl;
           }
           return 0;
           }