HDU 1233 还是畅通工程

还是畅通工程

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

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

 

 

方法一：Kruskal(克鲁斯卡尔)算法

第一步:排序

第二步：并查集算法

import java.io.*;

import java.util.*;

/*

 * @author denghuilong 

 *  

 * 2013-8-8上午12:41:03

 *

*/

public class Main {

	public static ArrayList<Path> ay;

	private static int[] patten;

	public static int n,m;

	public static void main(String[] args) {

		Scanner sc=new Scanner(new BufferedInputStream(System.in));

		while(sc.hasNextInt()){

			 n=sc.nextInt();

			if(n==0) break;

			m=n*(n-1)/2;

			ay=new ArrayList<Path>();

			for(int i=1;i<=m;i++){

				int a=sc.nextInt();

				int b=sc.nextInt();

				int d=sc.nextInt();

				Path p=new Path(a, b, d);

				ay.add(p);

			}

			

			Kruskal();

		}

	}

	//Kruskal(克鲁斯卡尔)算法

	public static void Kruskal(){

		//排序

		Collections.sort(ay);

		int count=0;

		patten=new int[n+1];

		//并查集  初始化

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

			patten[i]=i;

		}

		int i=0;

		//并查集  查找

		for(int j=0;j<m;j++) {

			int jj = patten[ay.get(j).a];

			int kk = patten[ay.get(j).b];

			if (jj != kk) {

				i++;

				count += ay.get(j).d;

				union(jj, kk);

			}

		}

		 if(i!=n-1)

			 System.exit(0);

		System.out.println(count);

	}

	// 并查集  合并

	public static void  union(int j, int k) {

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

			if (patten[i] == j) {

				patten[i] = k;

			}

		}

	}

}

class Path implements Comparable<Path>{

	int a;

	int b;

	int d;

	Path(int a,int b,int d){

		this.a=a;

		this.b=b;

		this.d=d;

	}



	public int compareTo(Path o) {

		return this.d>o.d?1:(this.d==o.d?0:-1);

	}

}

方法二：Prim（普里姆算法）

算法思想：可取图中任意一个顶点V作为生成树的根，之后若要往生成树上添加顶点W，则在顶点V和W之间必定存在一条边。并且该边的权值在所有连通顶点V和W之间的边中取值最小。

一般情况下，假设n个顶点分成两个集合：U（包含已落在生成树上的结点）和V-U（尚未落在生成树上的顶点），则在所有连通U中顶点和V-U中顶点的边中选取权值最小的边

 

import java.io.*;

import java.util.*;

/*

 * @author denghuilong 

 *  

 * 2013-8-8上午12:52:40

 *

*/

public class T1233 {

	public static int n,m;

	public static int M=102;

	public static int MAX=Integer.MAX_VALUE;

	public static int map[][]=new int[M][M];

	public static void main(String[] args) {

		Scanner sc=new Scanner(new BufferedInputStream(System.in));

		while(sc.hasNextInt()){

		    n=sc.nextInt();

			if(n==0) break;

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

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

					map[i][j]=MAX;

				}

			}

			m=(n-1)*n/2;

			for(int i=0;i<m;i++){

				int a=sc.nextInt();

				int b=sc.nextInt();

				int d=sc.nextInt();

				if(map[a][b]>d){

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

				}

			}

			getDistance();

		}

	}

	//Prim（普里姆算法）

	public static void getDistance(){

		int k=0,sum=0;

		int dis[]=new int[n+1];

		int mark[]=new int[n+1];

		for(int i=2;i<=n;i++){

			dis[i]=map[1][i];//初始化从起点到其他点之间的距离

			mark[i]=0;

		}

		mark[1]=0;

		//循环n-1次

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

			int min=MAX;

			//每次寻找最短的边

			for(int j=2;j<=n;j++){

				if(mark[j]==0&&dis[j]<min){

					min=dis[j];

					k=j;

				}

			}

			if(min==MAX) break;

			mark[k]=1;

			sum+=dis[k];

			// 到了一个新的点，重新计算它到其他点之间的距离

			for(int j=2;j<=n;j++){

				if(mark[j]==0&&dis[j]>map[k][j]){

					dis[j]=map[k][j];

				}

			}

		}

		System.out.println(sum);

	}

}