做题--并查集

• 详细入门
• 一般在遇到需要用到连通性的题干，第一反应应该想到用并查集。当然BFS，DFS也能解
• 一般模板如下。改进模板

private class UnionFind {
	// 记录节点的根
    private int[] parent;
    // 节点的秩，主要记录该节点目前位于的树的深度，从子节点出发。 主要用于优化，在合并两个父节点时，通过rank的大小判断谁父谁子
    private int[] rank;
	//初始化
    public UnionFind(int n) {
        this.parent = new int[n];
        this.rank = new int[n];
        for (int i = 0; i < n; i++) {
            this.parent[i] = i;
            this.rank[i] = 1;
        }
    }
	// 合并两个节点.如果处于同一个并查集， 不需要合并
    // 如果不处于同一个并查集，判断两个rootx和rooty谁的秩大
    public void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX == rootY) {
           return;
        }

        if (rank[rootX] == rank[rootY]) {
            parent[rootX] = rootY;
            // 此时以 rootY 为根结点的树的高度仅加了 1
            rank[rootY]++;
        } else if (rank[rootX] < rank[rootY]) {
            parent[rootX] = rootY;
            // 此时以 rootY 为根结点的树的高度不变
        } else {
            // 同理，此时以 rootX 为根结点的树的高度不变
            parent[rootY] = rootX;
        }
    }
	// 找某个节点的根.路径压缩,遍历过程中的所有父节点直接指向根节点，减少后续查找次数
    public int find(int x) {
        if (x != parent[x]) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
}

1. 等式方程的可满足行
   • 学习不使用类时union和find的写法

class Solution {
    public boolean equationsPossible(String[] equations) {
        //并查集。将所有==的元素连在一起，再判断！=的逻辑合理不合理
        int[] parent = new int[26];
        for(int i = 0;i<26;i++){
            parent[i] = i;
        }

        for(String equ:equations){
            if(equ.charAt(1)=='='){
                int left = equ.charAt(0)-'a';
                int right = equ.charAt(3)-'a';
                union(parent,left,right);
            }
        }

        for(String equ:equations){
            if(equ.charAt(1)=='!'){
                int left = equ.charAt(0)-'a';
                int right = equ.charAt(3)-'a';
                if(find(parent,left)==find(parent,right))
                    return false;
            }
        }
        return true;
    }

    public void union(int[] parent,int a,int b){
        parent[find(parent,a)] = find(parent,b);
    }

    public int find(int[] parent,int index){
         while (parent[index] != index) {
            parent[index] = parent[parent[index]];
            index = parent[index];
        }
        return index;
    }
}

3. 整数相除
4. 省份数量

public int findCircleNum(int[][] isConnected) {
        int res = 0;
        int n = isConnected.length;
        int[] parent = new int[n];
        //初始化
        for(int i = 0;i<n;i++){
            parent[i] = i;
        }
        //更新各个结点的根节点
        for(int i = 0;i<n;i++){
            for(int j = 0;j<n;j++){
                if(isConnected[i][j]==1){
                    parent[find(i,parent)]=find(j,parent);//注意这里，要找到各自的根
                }
            }
        }
        //通过计算有几个根节点，就能判断有几个连通区域，即几个省
        for(int i = 0;i<n;i++){
            if(parent[i]==i)
                res++;
        }
        return res;
    }

    private int find(int root,int[] parent){
        while(root!=parent[root])
            root=parent[root];
        return root;
    }