2006年浙大研究生复试机试真题-畅通工程

/*题目描述： 
    某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路
	交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。
输入： 
    测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，
	分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
    当N为0时，输入结束，该用例不被处理。

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

样例输入： 
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
样例输出:
3
5
*/
#include <cstdio>      //   My Program    -----------Prim algorithm -------------------------
#include <iostream>
#include <string.h>
using namespace std;
#define inf 999999
#define M 105
int visit[M];
int tu[M][M];
int dist[M];
int main()
{
	int N,n;
	int i,j,min;
	int a,b,dis;
//	freopen("f:/in.txt","r",stdin);
	while(scanf("%d",&N)!=EOF && N)
	{
		memset(visit,0,sizeof(visit));
		memset(tu,inf,sizeof(tu));
		memset(dist,inf,sizeof(dist));
		n=N*(N-1)/2;
		min=0;
		for(i=1;i<=n;i++)    //  input and saving
		{
			scanf("%d%d%d",&a,&b,&dis);
			tu[a][b]=tu[b][a]=dis;
		}
		dist[1]=0;
		visit[1]=1;
		for(i=2;i<=N;i++)
			dist[i]=tu[1][i];

		for(i=1;i<=N;i++)
		{
			int v=1;
			int temp=inf;
			for(j=1;j<=N;j++)    // find the closest node
			{
				if(!visit[j] && dist[j]<temp && dist[j]>0)
				{
					v=j;
					temp=dist[j];
				}
			}

			visit[v]=1;    //
			if(v!=1)
				min+=temp;
			for(j=1;j<=N;j++)  //  update
			{
				if(!visit[j] && dist[j]>tu[v][j])
					dist[j]=tu[v][j];
			}
		}
		printf("%d\n",min);
	}
//	fclose(stdin);
	return 0;
}


/*
                    //  ----------------并查集实现的kruskal 算法,最小生成树--------------------My Program
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

typedef struct{       //   定义边集
	int node1,node2;
	int weight;
}li;                  //
li t[5005];
int fa[105];          //   注意大小 
//int getFa(int n)      //  递归容易爆栈  ，建议用非递归
//{
//	if(n!=fa[n])
//		fa[n]=getFa(fa[n]);
//	return fa[n];  
//}
int getFa(int n)      //非递归
{
	int r=n,s;
	while(n!=fa[n])
		n=fa[n];
	while(r!=fa[n])
	{
		s=r;
		r=fa[r];
		fa[s]=fa[n];
	}
	return fa[n];
}
bool cmp(li a,li b)
{
	return a.weight<b.weight;
}
int main()
{
	int i,n,N,num;
	int a,b,dis,length;
	int arc[105][105];
	while(~scanf("%d",&N)&&N)
	{
		n=(N-1)*N/2;
		for(i=0;i<n;i++)
		{	
			scanf("%d%d%d",&a,&b,&dis);
			arc[a][b]=arc[b][a]=dis;
			t[i].node1=a;
			t[i].node2=b;
			t[i].weight=dis;
		}
		sort(t,t+n,cmp);              //边从小到大排序    be care of the edge of "n" ,  not N

		for(i=0;i<=N;i++)	fa[i]=i; 
		num=length=0;                    //Initiate

		for(i=0;i<n && num<N;i++)                        //时间复杂度  O( elog(e) )  e为边数
		{
			if(getFa( t[i].node1 )!=getFa( t[i].node2 ))         //     若不构成环，则合并
			{
				if(getFa( t[i].node1 ) > getFa( t[i].node2 ) )   //     也可以直接合并，此处指定父节点为编号较小的节点
					fa[ getFa( t[i].node1 )]=getFa( t[i].node2 );  
				else
					fa[ getFa( t[i].node2 )]=getFa( t[i].node1 );
				num++;
				length+=t[i].weight;
			}
		}
		printf("%d\n",length);
	}
	return 0;
}*/