hdu 1879 继续畅通工程

继续畅通工程

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 7884    Accepted Submission(s): 3374


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

 

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

当N为0时输入结束。
 

[align=left]Output[/align]
每个测试用例的输出占一行，输出全省畅通需要的最低成本。
 

[align=left]Sample Input[/align]

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

 

[align=left]Sample Output[/align]

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;
}
}

}