小白学并查集（java）

并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题。

并查集的思想：用一个数组表示了整片森林（parent），树的根节点唯一标识一个集合，只要找到了某个元素的的树根，就能确它在哪个集合里。

public static class Node<V>{
	V value;
	public Node(V v){
		value=v;
	}
}

public static class UnionFind<V>{
	public HashMap<V,Node<V>> nodes;
	public HashMap<Node<V>,Node<V>> parents;
	public HashMap<Node<V>,Integer> sizeMap;
	
	public UnionFind(List<V> values){
		nodes=new HashMap<>();
		parents=new HashMap<>();
		sizeMap=new HashMap<>();
		for(V cur:values){
			Node<V> node=new Node<>(cur);
			nodes.put(cur,node);
			parents.put(node,node);
			sizeMap.put(node,1);
		}
	}
	
	//给你一个节点，请你往上到不能再往上，把代表返回
	public Node<V> findFather(Node<V> cur){
		Stack<Node<V>> path=new Stack<>();
		while(cur!=parents.get(cur)){
			path.push(cur);
			cur=parents.get(cur);
		}
		while(!=path.isEmpty()){
			parents.put(path.pop(),cur);
		}
		return cur;
	}
	//判断两个值a和b是否属于同一个集合。通过比较它们的根节点是否相同来判断
	public boolean isSameSet(V a,V b){
	return findFather(nodes.get(a))==findFather(nodes.get(b));
	}
	
	public void union(V a,V b){
		Node<V> aHead=findFather(nodes.get(a));
		Node<V> bHead=findFather(nodes.get(b));
		if(aHead!=bHead){
			int aSetSize=sizeMap.get(aHead);
			int bSetSize=sizeMap.get(bHead);
			Node<V> big=aSetSize>=bSetSize?aHead:bHead;
			Node<V> small=big==aHead?bHead:aHead;
			parents.put(small,big);
			sizeMap.put(big,aSetSize+bSetSize);
			sizeMap.remove(small);
		}
	}
	
	public int sets(){
		return sizeMap.size();
	}

}

题1：

有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。

省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。

给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。

返回矩阵中 省份 的数量。

public static int findCircleNum(int[][] M){
	int N=M.length;
	UnionFind unionFind=new UnionFind(N);
	for(int i=0;i<N;i++){
		for(int j=i+1;j<N;j++){
			if(M[i][j]==1){//i和j互相认识
				unionFind.union(i,j);
			}
		}
	}
	return unionFind.sets();
}

public static class UnionFind(){
	private int[] parent;//parent[i]=k;i的父亲是k
	// size[i] = k ： 如果i是代表节点，size[i]才有意义，否则无意义
	// i所在的集合大小是多少
	private int[] size;
	//辅助结构
	private int[] help;
	//一共有多少个集合
	private int sets;
	public UnionFind(int N){
		parent=new int[N];
		size=new int[N];
		help=new int[N];
		sets=N;
		for(int i=0;i<N;i++){
			parent[i]=i;
			size[i]=1;
		}
	}
	// 从i开始一直往上，往上到不能再往上，代表节点，返回
	// 这个过程要做路径压缩
	private int find(int i){
		int hi=0;
		while(i!=parent[i]){
			help[hi++]=i;
			i=parent[i];
		}
		for(hi--;hi>=0;hi--){
			parent[help[hi]]=i;
		}
		return i;
	}
	
	public void union(int i,int j){
		int f1=find(i);
		int f2=find(j);
		if(f1!=f2){
			if(size[f1]>=size[f2]){
				size[f1]+=size[f2];
				parent[f2]=f1;
			}else{
				size[f2]+=size[f1];
				parent[f1]=f2;
			}
			sets--;
		}
	}
	public int sets() {
		return sets;
	}
}
	
	
}

题2：给定一个二维数组matrix，里面的值不是1就是0，上下左右相邻认为是一片岛，返回matrix中岛的数量

dot解释（字符按值传递，所以需要它分辨不同的1）：

法1：

public static int numIslands3(char[][] board){
	int islands=0;
	for(int i=0;i<board.length;i++){
		for(int j=0;j<board[0].length;j++){
			if(board[i][j]=='1'){
				islands++;
				infect(board,i,j);
			}
		}
	}
	return islands;
}

//从(i,j)这个位置出发，把所有练成一片的'1'字符，变成0
public static void infect(char[][] board,int i,int j){
	if(i<0||i==board.length||j<0||j==board[0].length||board[i][j]!='1'){
		return;
	}
	board[i][j]=0;
	infect(board,i-1,j);
	infect(board,i+1,j);
	infect(board,i,j-1);
	infect(board,i,j+1);
}

法2：

public static int numIslands1(char[][] board){
	int row=board.length;
	int col=board[0].length;
	Dot[][] dots=new Dot[row][col];
	List<Dot> dotList=new ArrayList<>();
	for(int i=0;i<row;i++){
		for(int j=0;j<col;j++){
			if(board[i][j]=='1'){
				dots[i][j]=new Dot();
				dotList.add(dots[i][j]);
			}
		}
	}
	UnionFind1<Dot> uf=new UnionFind1<>(dotList);
	for(int j=1;j<col;j++){
		if(board[0][j-1]=='1'&&board[0][j]=='1'){
			uf.union(dots[0][j-1],dots[0][j]);
		}
	}
	for(int i=1;i<row;i++){
		if(board[i-1][0]=='1'&&board[i][0]=='1'){
			uf.union(dots[i-1][0],dots[i][0]);
		}
	}
	for (int i = 1; i < row; i++) {
		for (int j = 1; j < col; j++) {
			if (board[i][j] == '1') {
				if (board[i][j - 1] == '1') {
					uf.union(dots[i][j - 1], dots[i][j]);
				}
				if (board[i - 1][j] == '1') {
					uf.union(dots[i - 1][j], dots[i][j]);
				}
			}
		}
	}
	return uf.sets();
		
}
public static class Dot {

	}

	public static class Node<V> {

		V value;

		public Node(V v) {
			value = v;
		}

	}

	public static class UnionFind1<V> {
		public HashMap<V, Node<V>> nodes;
		public HashMap<Node<V>, Node<V>> parents;
		public HashMap<Node<V>, Integer> sizeMap;

		public UnionFind1(List<V> values) {
			nodes = new HashMap<>();
			parents = new HashMap<>();
			sizeMap = new HashMap<>();
			for (V cur : values) {
				Node<V> node = new Node<>(cur);
				nodes.put(cur, node);
				parents.put(node, node);
				sizeMap.put(node, 1);
			}
		}

		public Node<V> findFather(Node<V> cur) {
			Stack<Node<V>> path = new Stack<>();
			while (cur != parents.get(cur)) {
				path.push(cur);
				cur = parents.get(cur);
			}
			while (!path.isEmpty()) {
				parents.put(path.pop(), cur);
			}
			return cur;
		}

		public void union(V a, V b) {
			Node<V> aHead = findFather(nodes.get(a));
			Node<V> bHead = findFather(nodes.get(b));
			if (aHead != bHead) {
				int aSetSize = sizeMap.get(aHead);
				int bSetSize = sizeMap.get(bHead);
				Node<V> big = aSetSize >= bSetSize ? aHead : bHead;
				Node<V> small = big == aHead ? bHead : aHead;
				parents.put(small, big);
				sizeMap.put(big, aSetSize + bSetSize);
				sizeMap.remove(small);
			}
		}

		public int sets() {
			return sizeMap.size();
		}

	}

法3：

public static int numIslands2(char[][] board) {
		int row = board.length;
		int col = board[0].length;
		UnionFind2 uf = new UnionFind2(board);
		for (int j = 1; j < col; j++) {
			if (board[0][j - 1] == '1' && board[0][j] == '1') {
				uf.union(0, j - 1, 0, j);
			}
		}
		for (int i = 1; i < row; i++) {
			if (board[i - 1][0] == '1' && board[i][0] == '1') {
				uf.union(i - 1, 0, i, 0);
			}
		}
		for (int i = 1; i < row; i++) {
			for (int j = 1; j < col; j++) {
				if (board[i][j] == '1') {
					if (board[i][j - 1] == '1') {
						uf.union(i, j - 1, i, j);
					}
					if (board[i - 1][j] == '1') {
						uf.union(i - 1, j, i, j);
					}
				}
			}
		}
		return uf.sets();
	}

	public static class UnionFind2 {
		private int[] parent;
		private int[] size;
		private int[] help;
		private int col;
		private int sets;

		public UnionFind2(char[][] board) {
			col = board[0].length;
			sets = 0;
			int row = board.length;
			int len = row * col;
			parent = new int[len];
			size = new int[len];
			help = new int[len];
			for (int r = 0; r < row; r++) {
				for (int c = 0; c < col; c++) {
					if (board[r][c] == '1') {
						int i = index(r, c);
						parent[i] = i;
						size[i] = 1;
						sets++;
					}
				}
			}
		}

		// (r,c) -> i
		private int index(int r, int c) {
			return r * col + c;
		}

		// 原始位置 -> 下标
		private int find(int i) {
			int hi = 0;
			while (i != parent[i]) {
				help[hi++] = i;
				i = parent[i];
			}
			for (hi--; hi >= 0; hi--) {
				parent[help[hi]] = i;
			}
			return i;
		}

		public void union(int r1, int c1, int r2, int c2) {
			int i1 = index(r1, c1);
			int i2 = index(r2, c2);
			int f1 = find(i1);
			int f2 = find(i2);
			if (f1 != f2) {
				if (size[f1] >= size[f2]) {
					size[f1] += size[f2];
					parent[f2] = f1;
				} else {
					size[f2] += size[f1];
					parent[f1] = f2;
				}
				sets--;
			}
		}

		public int sets() {
			return sets;
		}

	}

题3：（题2plus）假设你设计一个游戏，用一个 m 行 n 列的 2D 网格来存储你的游戏地图。

起始的时候，每个格子的地形都被默认标记为「水」。
我们可以通过使用 addLand 进行操作，将位置 (row, col) 的「水」变成「陆地」。

你将会被给定一个列表，来记录所有需要被操作的位置，然后你需要返回计算出来 每次 addLand 操作后岛屿的数量。

注意：一个岛的定义是被「水」包围的「陆地」，通过水平方向或者垂直方向上相邻的陆地连接而成。
你可以假设地图网格的四边均被无边无际的「水」所包围。

法1： 

//m：岛屿的行数。
	//n：岛屿的列数。
	//positions：一个二维数组，包含岛屿的位置
	public static List<Integer> numIslands21(int m, int n, int[][] positions) {
		UnionFind1 uf = new UnionFind1(m, n);
		List<Integer> ans = new ArrayList<>();
		for (int[] position : positions) {
			//position[0]和position[1]分别是岛屿的行索引和列索引
			ans.add(uf.connect(position[0], position[1]));
		}
		return ans;
	}

	public static class UnionFind1 {
		private int[] parent;//用于存储每个元素的父节点的数组。
		private int[] size;//用于存储每个集合的大小
		private int[] help;//辅助数组，用于路径压缩优化。
		private final int row;//岛屿的行数
		private final int col;//岛屿的列数
		private int sets;//当前的集合数量

		public UnionFind1(int m, int n) {
			row = m;
			col = n;
			sets = 0;
			int len = row * col;
			parent = new int[len];
			size = new int[len];
			help = new int[len];
		}

		//计算行列索引对应的一维数组索引
		private int index(int r, int c) {
			return r * col + c;
		}

		//查找元素i的根节点，并进行路径压缩优化。
		private int find(int i) {
			int hi = 0;//这是一个辅助变量，用于记录当前查找路径的长度
			//这个循环的目的是找到元素i的根节点（即直接指向自己的节点）。
			// 循环条件是i不等于其父节点parent[i]，这意味着i不是根节点。
			while (i != parent[i]) {
				help[hi++] = i;//将当前节点i的索引存储到help数组中，并将hi加1，表示路径长度增加。
				i = parent[i];//将i更新为其父节点的索引，继续向上查找。
			}
			//当while循环结束时，我们找到了根节点，并且help数组中存储了从元素i到根节点的路径。
			// 这个for循环的目的是对这条路径进行“路径压缩”，即直接将路径上的所有节点的父节点指向根节点。
			for (hi--; hi >= 0; hi--) {
				parent[help[hi]] = i;
			}
			return i;
		}

		//合并两个岛屿，首先检查岛屿是否有效，然后通过索引找到对应的元素，并调用find方法找到根节点，最后合并两个集合
		private void union(int r1, int c1, int r2, int c2) {
			if (r1 < 0 || r1 == row || r2 < 0 || r2 == row || c1 < 0 || c1 == col || c2 < 0 || c2 == col) {
				return;
			}
			int i1 = index(r1, c1);
			int i2 = index(r2, c2);
			if (size[i1] == 0 || size[i2] == 0) {
				return;
			}
			int f1 = find(i1);
			int f2 = find(i2);
			if (f1 != f2) {
				if (size[f1] >= size[f2]) {
					size[f1] += size[f2];
					parent[f2] = f1;
				} else {
					size[f2] += size[f1];
					parent[f1] = f2;
				}
				sets--;
			}
		}

		//连接岛屿的公共方法。首先计算岛屿的索引，检查该岛屿是否已经被连接（即size[index]是否为0），
		// 如果是新岛屿，则初始化并增加集合数量。然后调用union方法尝试与相邻的岛屿合并，并返回当前的集合数量。
		public int connect(int r, int c) {
			int index = index(r, c);
			if (size[index] == 0) {
				parent[index] = index;
				size[index] = 1;
				sets++;
				union(r - 1, c, r, c);
				union(r + 1, c, r, c);
				union(r, c - 1, r, c);
				union(r, c + 1, r, c);
			}
			return sets;
		}

	}

法2：

public static List<Integer> numIslands22(int m, int n, int[][] positions) {
		UnionFind2 uf = new UnionFind2();
		List<Integer> ans = new ArrayList<>();
		for (int[] position : positions) {
			ans.add(uf.connect(position[0], position[1]));
		}
		return ans;
	}

	public static class UnionFind2 {
		private HashMap<String, String> parent;
		private HashMap<String, Integer> size;
		private ArrayList<String> help;
		private int sets;

		public UnionFind2() {
			parent = new HashMap<>();
			size = new HashMap<>();
			help = new ArrayList<>();
			sets = 0;
		}

		private String find(String cur) {
			while (!cur.equals(parent.get(cur))) {
				help.add(cur);
				cur = parent.get(cur);
			}
			for (String str : help) {
				parent.put(str, cur);
			}
			help.clear();
			return cur;
		}

		private void union(String s1, String s2) {
			if (parent.containsKey(s1) && parent.containsKey(s2)) {
				String f1 = find(s1);
				String f2 = find(s2);
				if (!f1.equals(f2)) {
					int size1 = size.get(f1);
					int size2 = size.get(f2);
					String big = size1 >= size2 ? f1 : f2;
					String small = big == f1 ? f2 : f1;
					parent.put(small, big);
					size.put(big, size1 + size2);
					sets--;
				}
			}
		}

		public int connect(int r, int c) {
        //将行索引和列索引组合成一个字符串键key，用于在parent和size映射中唯一标识这个岛屿节点。
			String key = String.valueOf(r) + "_" + String.valueOf(c);
			if (!parent.containsKey(key)) {
				parent.put(key, key);
				size.put(key, 1);
				sets++;
                //分别生成上、下、左、右相邻岛屿的键。
				String up = String.valueOf(r - 1) + "_" + String.valueOf(c);
				String down = String.valueOf(r + 1) + "_" + String.valueOf(c);
				String left = String.valueOf(r) + "_" + String.valueOf(c - 1);
				String right = String.valueOf(r) + "_" + String.valueOf(c + 1);
				union(up, key);
				union(down, key);
				union(left, key);
				union(right, key);
			}
			return sets;
		}

	}