并查集的实现 及 相关题目

并查集实现

并查集的本质是通过一个一维数组来维护一个森林。开始时森林中的每一个节点都是孤立的，各自形成一个树。之后，进行若干次的合并操作，每次合并将两个树合并为一个更大的树。

实现思路

代码实现

import java.util.HashMap;
import java.util.List;
import java.util.Stack;

public class Code05_UnionFind {
    public static class Node<V> {
        V value;

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

    public static class UnionFind<V> {
        // 值和Node的映射关系
        public HashMap<V, Node<V>> nodes;
        // 指向自己父类的集合
        public HashMap<Node<V>, Node<V>> parents;
        // 表明当前代表节点所表示的集合的大小
        public HashMap<Node<V>, Integer> sizeMap;

        public UnionFind(List<V> values) {
            this.nodes = new HashMap<>();
            this.parents = new HashMap<>();
            this.sizeMap = new HashMap<>();
            // 初始化三个集合
            for (V value : values) {
                Node<V> node = new Node<>(value);
                nodes.put(value, node);
                parents.put(node, node);
                sizeMap.put(node, 1);
            }
        }

        // 给你一个节点，请你往上到不能再往上，把代表返回
        public Node<V> findFather(Node<V> cur) {
            Stack<Node<V>> path = new Stack<>();
            // 当cur的父节点不是他自己的时候, 一直向上找到代表结点
            while (cur != parents.get(cur)) {
                path.push(cur);
                cur = parents.get(cur);
            }
            // 将路径上的节点父类都设置为代表结点
            while (!path.isEmpty()) {
                parents.put(path.pop(), cur);
            }
            return cur;
        }

        // 两个值是否在同一个集合中
        public boolean isSameSet(V a, V b) {
            return findFather(nodes.get(a)) == findFather(nodes.get(b));
        }

        // 合并a，b两个元素所在集合
        public void union(V a, V b) {
            // 首先获取两个元素的代表节点
            Node<V> aHead = findFather(nodes.get(a));
            Node<V> bHead = findFather(nodes.get(b));
            // 如果aHead == bHead 表示两集合代表节点一致，不需要合并
            if (aHead != bHead) {
                // 获取两集合大小
                Integer aSetSize = sizeMap.get(aHead);
                Integer 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();
        }
    }
}

相关题目

LeetCode 547. 省份数量

思路

代码实现

class Solution {
    public int findCircleNum(int[][] isConnected) {
        int N = isConnected.length;
        // 初始化并查集 0 1 2 ... N-1
        UnionFind unionFind = new UnionFind(N);
        for(int i = 0; i < N; i++) {
            for(int j = i + 1; j < N; j++) {
                if(isConnected[i][j] == 1) {
                    unionFind.union(i, j);
                }
            }
        }
        return unionFind.set();
    }

    // 数组实现并查集
    public class UnionFind {
        // parent[i] = k: i 的父亲是 k
        public int[] parent;
        // size[i] = k: 如果i是代表节点，size[i]才有意义，表示i所在集合的大小
        public int[] size;
        // 辅助数组，作为栈存在
        public int[] help;
        // 一共有多少个集合
        public 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开始一直往上，往上到不能再往上，代表节点，返回
		// 这个过程要做路径压缩
        public int find(int i) {
            int hi = 0;
            // 向上找父节点，最后i就是代表节点
            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 set() {
            return sets;
        }
    }
}