leetcode03. Find the Weak Connected Component in the Directed Graph_find-the-weak-connected-component-in-the-directed--优快云博客

本文链接：https://blog.youkuaiyun.com/rxt2012kc/article/details/78046119

本文介绍了一种用于解决图论中连接性问题的数据结构——并查集，并详细展示了其核心方法，包括查找与合并操作的具体实现。此外，还提供了一个在无向图中寻找连通分量的应用实例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

解法

UnionFind

/**
 * @Author RenXintao
 * @Date 9/20/17
 * @method: UnionFind
 */
class UnionFind {
    HashMap<Integer, Integer> father = new HashMap<>();
    UnionFind(HashSet<Integer> hashSet) {
        for (Integer now : hashSet) {
            father.put(now, now);
        }
    }
    int find(int x) {
        int parent = father.get(x);
        while (parent != father.get(parent)) {
            parent = father.get(parent);
        }

        return parent;
    }
    int compressed_find(int x) {
        int parent = father.get(x);
        while (parent != father.get(parent)) {
            parent = father.get(parent);
        }

        int next;
        while (x != father.get(x)) {
            next = father.get(x);
            father.put(x, parent);
            x = next;
        }

        return parent;
    }
    void union(int x, int y) {
        int fa_x = father.get(x);
        int fa_y = father.get(y);
        if (fa_x != fa_y) {
            father.put(fa_x, fa_y);
        }
    }

}
public class FindTheConnectedComponentInTheUndirectedGraph_lint_3_1 {
    List<List<Integer>> print(HashSet<Integer> hashSet, UnionFind uf, int n) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        HashMap<Integer, List<Integer>> hashMap = new HashMap<Integer, List<Integer>>();
        for (int i : hashSet) {
            int fa = uf.find(i);
            if (!hashMap.containsKey(fa)) {
                hashMap.put(fa, new ArrayList<Integer>());
            }
            List<Integer> now = hashMap.get(fa);
            now.add(i);
            hashMap.put(fa, now);
        }

        for (List<Integer> now : hashMap.values()) {
            Collections.sort(now);
            ans.add(now);
        }

        return ans;
    }
    public List<List<Integer>> connnectedSet(ArrayList<UndirectedGraphNode> nodes) {
        HashSet<Integer> hashSet = new HashSet<>();
        for (UndirectedGraphNode now : nodes) {
            hashSet.add(now.label);
            for (UndirectedGraphNode neighbour : now.neighbors) {
                hashSet.add(neighbour.label);
            }
        }

        UnionFind uf = new UnionFind(hashSet);

        for (UndirectedGraphNode now : nodes) {
            for (UndirectedGraphNode neighbour : now.neighbors) {
                int fnow = uf.find(now.label);
                int fneighbour = uf.find(neighbour.label);
                if (fnow != fneighbour) {
                    uf.union(now.label, neighbour.label);
                }
            }
        }

        return print(hashSet, uf, nodes.size());
    }
}