hdu 1879 继续畅通工程

继续畅通工程

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7884    Accepted Submission(s): 3374

Problem Description

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建道路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全省畅通需要的最低成本。

 

Input

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( 1< N < 100 )；随后的 N(N-1)/2 行对应村庄间道路的成本及修建状态，每行给4个正整数，分别是两个村庄的编号（从1编号到N），此两村庄间道路的成本，以及修建状态：1表示已建，0表示未建。

当N为0时输入结束。

 

Output

每个测试用例的输出占一行，输出全省畅通需要的最低成本。

 

Sample Input

   
   

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

 

Sample Output

   
   

    
    3
1
0
   
   
   
   

    
     
   
   
   
   

    
    
package hd;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.PriorityQueue;
/** 
 *  @功能Function Description:  kruskal算法
 *  @开发环境Environment:        eclipse 
 *  @技术特点Technique:            
 *  @算法                          
 *  @版本Version:               Scanner 
 *  @作者Author:                follow your dreams 
 *  @日期Date:                  20120830 
 *  @备注Notes:                 运行时间：27XXms
 *  @链接：                      http://acm.hdu.edu.cn/showproblem.php?pid=1879
 */
public class HD1879_1_20120830 {
	
	public static PriorityQueue<Node> pq;
	
	public static int father[];

	public static void main(String[] args) throws IOException {
		StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		int count, a, b, value, flag, countCase;
		pq = new PriorityQueue<Node>();
		while(st.nextToken() != StreamTokenizer.TT_EOF) {
			count = (int)st.nval;
			if(count == 0) {
				break;
			}
			father = new int[count+1];
			makeSet();
			countCase = count*(count-1)/2; 
			for(int i=1; i<=countCase; i++) {
				st.nextToken();
				a = (int)st.nval;
				st.nextToken();
				b = (int)st.nval;
				st.nextToken();
				value = (int)st.nval;
				st.nextToken();
				flag = (int)st.nval;
				if(flag == 1) {
					pq.add(createNode(a, b, 0));
				} else {
					pq.add(createNode(a, b, value));
				}
			}
			System.out.println(kruskal(count));
			pq.clear();
		}
	}
	
	public static void makeSet() {
		int len = father.length;
		for(int i=1; i<len; i++) {
			father[i] = i;
		}
	}
	
	public static int find(int x) {
		if(x != father[x]) {
			father[x] = find(father[x]);
		}
		return father[x];
	}
	
	public static void union(int x, int y) {
		x = find(x);
		y = find(y);
		if(x != y) {
			father[x] = y;
		}
	}
	
	public static int kruskal(int count) {
		int sum = 0;
		int len = 0;
		int set1, set2;
		while(len!=count-1) {
			Node temp = pq.poll();
			set1 = find(temp.a);
			set2 = find(temp.b);
			if(set1 != set2) {
				union(set1, set2);
				sum += temp.value;
				len ++;
			}
		}
		return sum;
	}
	
	public static Node createNode(int a, int b, int value) {
		return new HD1879_1_20120830().new Node(a, b, value);
	}
	
	private class Node implements Comparable<Node>{
		int a;
		int b;
		int value;
		public Node(int a, int b, int value) {
			this.a = a;
			this.b = b;
			this.value = value;
		}
		@Override
		public int compareTo(Node arg0) {
			return this.value - arg0.value;
		}	
	}

}