畅通工程问题-并查集

题目

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。
省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？

Input
测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；
随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。
注意:两个城市之间可以有多条道路相通,也就是说
3 3
1 2
1 2
2 1
这种输入也是合法的
当N为0时，输入结束，该用例不被处理。

Output
对每个测试用例，在1行里输出最少还需要建设的道路数目。
Sample Input
4 2
1 3
4 3
3 3
1 2
1 3
2 3
5 2
1 2
3 5
999 0
0

Sample Output
1
0
2
998

这一题是一个赤裸裸的并查集问题

public class Engineering {
	//towns[i]表示i节点的头节点，size[i]表示i节点所在的集合的长度
	public int[] towns;
	public int[] size;
	public void init(int num){
		towns = new int[num + 1];
		size = new int[num + 1];
		for(int i = 1 ; i < towns.length ; i++){
			towns[i] = i;
			size[i] = 1;
		}
	}
	public int findHead(int i){
		int head = towns[i];
		if(head != towns[i]){
			head = findHead(head);
		}
		towns[i] = head;
		return head;
	}
	public boolean isSameSet(int i,int j){
		return findHead(i) == findHead(j);
	}
	public void union(int i,int j){
		int head1 = findHead(i);
		int head2 = findHead(j);
		if(head1 != head2){
			int size1 = size[head1];
			int size2 = size[head2];
			if(size1 > size2){
				towns[j] = head1;
				size[head1] = size1 + size2;
			}else{
				towns[i] = head2;
				size[head2] = size1 + size2;
			}
		}
	}

	public void solution(){
		Scanner sc = new Scanner(System.in);
		int length;
		List<Integer> result = new ArrayList<>();
		while((length = sc.nextInt()) != 0){
			init(length);
			int builded = sc.nextInt();
			for(int i = 0; i < builded ; i++){
				union(sc.nextInt(),sc.nextInt());
			}
			//设为-1的原因：头结点肯定指向自己
			int needRoad = -1;
			for(int i = 1 ; i < towns.length ; i++){
				if(towns[i] == i)
					needRoad ++;
			}
			result.add(needRoad);
		}
		for(Integer i : result){
			System.out.println(i);
		}
	}

	public static void main(String[] args) {
		Engineering engineering = new Engineering();
		engineering.solution();
	}
}

出于解题的便捷，题目的并查集结构并不完整，下面提供一个通用的并查集结构

/**
 * 并查集
 * 必须一开始就给它所有数据
 * 两个功能：1.两个元素所在集合是否是同一个
 * 			2.将两个元素所在的集合合并
 */
public class UnionFindSet {
	public HashMap<Node,Node> fatherMap;
	//记录每一个节点所在集合的大小
	public HashMap<Node,Integer> sizeMap;
	public UnionFindSet(){
		fatherMap = new HashMap<>();
		sizeMap = new HashMap<>();
	}
	public void makeSet(List<Node> nodes){
		//初始化fatherMap和sizeMap
		fatherMap.clear();
		sizeMap.clear();
		for(Node node : nodes){
			fatherMap.put(node,node);
			sizeMap.put(node,1);
		}
	}

	/**寻找节点的头节点
	 * 递归的过程中，将每一个子节点的头节点都指向最上层的头节点
	 */
	private Node findHead(Node node){
		Node father = fatherMap.get(node);
		if(father != node){
			father = findHead(father);
		}
		fatherMap.put(node,father);
		return father;
	}
	public boolean isSameSet(Node node1,Node node2){
		return findHead(node1) == findHead(node2);
	}
	public void union(Node node1,Node node2){
		if(node1 == null || node2 == null){
			return;
		}
		Node father1 = findHead(node1);
		Node father2 = findHead(node2);
		if(father1 != father2){
			Integer size1 = sizeMap.get(father1);
			Integer size2 = sizeMap.get(father2);
			if(size1 >= size2){
				fatherMap.put(father2,father1);
				//因为只有需要用到size时只会取头节点的size，所以只需要修改头节点的size即可，其他节点的不需要修改
				sizeMap.put(father1,size1 + size2);
			}else{
				fatherMap.put(father1,father2);
				sizeMap.put(father2,size1 + size2);
			}
		}
	}
}