Java实现历届试题 城市建设 第二版本

历届试题 城市建设（已解决只通过50%问题）

问题描述
　　栋栋居住在一个繁华的C市中，然而，这个城市的道路大都年久失修。市长准备重新修一些路以方便市民，于是找到了栋栋，希望栋栋能帮助他。

C市中有n个比较重要的地点，市长希望这些地点重点被考虑。现在可以修一些道路来连接其中的一些地点，每条道路可以连接其中的两个地点。另外由于C市有一条河从中穿过，也可以在其中的一些地点建设码头，所有建了码头的地点可以通过河道连接。

栋栋拿到了允许建设的道路的信息，包括每条可以建设的道路的花费，以及哪些地点可以建设码头和建设码头的花费。

市长希望栋栋给出一个方案，使得任意两个地点能只通过新修的路或者河道互达，同时花费尽量小。
输入格式
　　输入的第一行包含两个整数n, m，分别表示C市中重要地点的个数和可以建设的道路条数。所有地点从1到n依次编号。
　　接下来m行，每行三个整数a, b, c，表示可以建设一条从地点a到地点b的道路，花费为c。若c为正，表示建设是花钱的，如果c为负，则表示建设了道路后还可以赚钱（比如建设收费道路）。
　　接下来一行，包含n个整数w_1, w_2, …, w_n。如果w_i为正数，则表示在地点i建设码头的花费，如果w_i为-1，则表示地点i无法建设码头。
　　输入保证至少存在一个方法使得任意两个地点能只通过新修的路或者河道互达。
输出格式
　　输出一行，包含一个整数，表示使得所有地点通过新修道路或者码头连接的最小花费。如果满足条件的情况下还能赚钱，那么你应该输出一个负数。
样例输入
5 5
1 2 4
1 3 -1
2 3 3
2 4 5
4 5 10
-1 10 10 1 1
样例输出
9
样例说明
　　建设第2、3、4条道路，在地点4、5建设码头，总的花费为9。
数据规模和约定
　　对于20%的数据，1<=n<=10，1<=m<=20，0<=c<=20，w_i<=20；
　　对于50%的数据，1<=n<=100，1<=m<=1000，-50<=c<=50，w_i<=50；
　　对于70%的数据，1<=n<=1000；
　　对于100%的数据，1 <= n <= 10000，1 <= m <= 100000，-1000<=c<=1000，-1<=w_i<=1000，w_i≠0。

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Main {
	static List<Edge> edgeList = new ArrayList<Edge>();
	static Set<Edge> T = new HashSet<>();
	static int n;
	static Map<Integer, UnionFind.UFNode> pntAndNode = new HashMap<Integer, UnionFind.UFNode>();
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		int m = sc.nextInt();
		while(m-- > 0 ){
			edgeList.add(new Edge(sc.nextInt(),sc.nextInt(),sc.nextInt()));
		}
		for(int i = 1; i <= n; i++){
			int dis = sc.nextInt();
			if(dis != -1){
				edgeList.add(new Edge(0,i,dis));
			}
		}
		buildMap();
		
		Set<Edge> t = getT();
		int res = 0;
		int count = 0;
		int cou = 0;
		for (Edge edge : t) {
			if(edge.getEnd()==0){
				count++;
				cou = edge.getDistance();
			}
			if(edge.getStart() == 0){
				count++;
				cou = edge.getDistance();
			}
			res += edge.distance;
		}
		if(count == 1){//如果去河道（虚拟节点）的边等于一条则不要，应减去该条的价值
			res -= cou;
		}
		System.out.println(res);
	}
	private static Set<Edge> getT() {
		
		buildMis();
	
		return T;
	}
	private static void buildMis() {
		Collections.sort(edgeList);
		for (Edge e: edgeList) {
			if(!ok(e)){
				if(e.distance < 0){//只要是赚钱的桥都建不管联通不
					T.add(e);
					n +=1;//边要递增
				}
				continue;
			}
			T.add(e);
			
			if(T.size() == n){
				return ;
			}
		}
	}
	private static boolean ok(Edge e) {
		UnionFind.UFNode x = pntAndNode.get(e.getStart());
		UnionFind.UFNode y = pntAndNode.get(e.getEnd());
		if(UnionFind.find(x) != UnionFind.find(y)){
			UnionFind.UnionNode(x, y);
			return true;
		}
		return false;
	}
	private static void buildMap() {
		for (Edge edge : edgeList) {
			pntAndNode.put(edge.start, new UnionFind.UFNode());
			pntAndNode.put(edge.end, new UnionFind.UFNode());
		}
	}

}
class UnionFind{
	public static UFNode find(UFNode x){
		UFNode p = x;
		Set<UFNode> n = new HashSet<>();
		while(p.parent != null){
			n.add(p);
			p = p.parent;
		}
		for (UFNode node : n) {
			node.parent = p;
		}
		return p;
	}
	public static void UnionNode(UFNode x,UFNode y){
		UnionFind.find(y).parent = UnionFind.find(x);
	}
	public static class UFNode{
		public UFNode parent;

		@Override
		public String toString() {
			return "UFNode [parent=" + parent + "]";
		}
		
	}
}
class Edge implements Comparable<Edge>{
	public Integer start;
	public Integer end;
	public Integer distance;
	
	public Edge(Integer start, Integer end, Integer distance) {
		super();
		this.start = start;
		this.end = end;
		this.distance = distance;
	}

	public Integer getStart() {
		return start;
	}

	public Integer getEnd() {
		return end;
	}

	public Integer getDistance() {
		return distance;
	}

	@Override
	public String toString() {
		return "Edge [start=" + start + ", end=" + end + ", distance=" + distance + "]";
	}

	@Override
	public int compareTo(Edge o) {
		// TODO Auto-generated method stub
		return this.distance - o.distance;
	}
	
}