并查集(java)

快速查找

public class UnionFind_QF {
    int nums[];
    public UnionFind_QF(int  k) {
        nums=new int[k];
        for (int i = 0; i < nums.length; i++) {
            nums[i]=i;
        }
    }
    public void Union(int x,int y){
        int xParent=Find(x);
        int yParent=Find(y);
        if(yParent!= xParent){
            for (int i = 0; i < nums.length; i++) {
                if(nums[i]==xParent){
                    nums[i]=yParent;
                }
            }
        }
    }
    private int  Find(int x){
       return  nums[x];
    }
    public boolean isUnion(int x,int y){;
        return Find(x)==Find(y);
    }
}

快速合并

public class UnionFind_QU {
    int nums[];

    public UnionFind_QU(int k) {
        nums = new int[k];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i;
        }
    }

    public void Union(int x, int y) {
        int xParent = Find(x);
        int yParent = Find(y);
        if (xParent != yParent)
            nums[xParent] = yParent;
    }

    public int Find(int x) {
        while (x != nums[x]) {
            x = nums[x];
        }
        return x;
    }

    public boolean isUnion(int x, int y) {
        return Find(x) == Find(y);
    }

}

快速合并&基于节点数量

public class UnionFind_QU_S {
    int nums[];
    int size[];

    public UnionFind_QU_S(int k) {
        nums = new int[k];
        size = new int[k];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i;
            size[i] = 1;
        }
    }

    public void Union(int x, int y) {
        int xParent = Find(x);
        int yParent = Find(y);
        if (xParent != yParent)
            if (size[xParent] <= size[yParent]) {
                size[yParent]+=size[xParent];
                nums[xParent] = yParent;
            } else {
                size[xParent]+=size[yParent];
                nums[yParent] = xParent;
            }
    }

    public int Find(int x) {
        while (x != nums[x]) {
            x = nums[x];
        }
        return x;
    }

    public boolean isUnion(int x, int y) {
        return Find(x) == Find(y);
    }

}

快速合并&基于节点深度

public class UnionFind_QU_D {
    int nums[];
    int deep[];

    public UnionFind_QU_D(int k) {
        nums = new int[k];
        deep = new int[k];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i;
            deep[i] = 1;
        }
    }


    public void Union(int x, int y) {
        int xParent = Find(x);
        int yParent = Find(y);
        if (xParent != yParent)
            if (deep[xParent] < deep[yParent]) {
                nums[xParent] = yParent;
            } else if (deep[xParent] > deep[yParent]) {
                nums[yParent] = xParent;
            } else {
                deep[yParent]++;
                nums[xParent] = yParent;
            }
    }

    public int Find(int x) {
        while (x != nums[x]) {
            x = nums[x];
        }
        return x;
    }

    public boolean isUnion(int x, int y) {
        return Find(x) == Find(y);
    }
}

快速合并&基于节点深度&路径分裂

public class UnionFind_QU_D_PS {
    int nums[];
    int deep[];

    public UnionFind_QU_D_PS(int k) {
        nums = new int[k];
        deep = new int[k];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i;
            deep[i] = 1;
        }
    }


    public void Union(int x, int y) {
        int xParent = Find(x);
        int yParent = Find(y);
        if (xParent != yParent)
            if (deep[xParent] < deep[yParent]) {
                nums[xParent] = yParent;
            } else if (deep[xParent] > deep[yParent]) {
                nums[yParent] = xParent;
            } else {
                deep[yParent]++;
                nums[xParent] = yParent;
            }
    }

    public int Find(int x) {
        while (x != nums[x]) {
            int v=nums[x];
            nums[x]=nums[nums[x]];
            x=v;
        }
        return x;
    }

    public boolean isUnion(int x, int y) {
        return Find(x) == Find(y);
    }
}

快速合并&基于节点深度&路径分裂&通用版

import java.util.HashMap;
import java.util.Objects;

public class UnionFind_Universal<V> {
//   public  Assist<V> assistor;
//
//    public interface Assist<V> {
//        public int hashCode();
//        public boolean equals(Object obj);
//    }
//
//    public UnionFind_Universal(Assist<V> assistor) {
//        this.assistor = assistor;
//        set = new HashMap<>();
//    }

    public UnionFind_Universal() {
    }

    private static class Node<V> {
        V value;
        Node<V> parent;

        int deep;

        Node(V v) {
            value = v;
            parent = this;
            deep = 1;
        }
    }

    private HashMap<V, Node<V>> set = new HashMap<>();

    private V Find(V v) {
        Node<V> vnode = set.get(v);
        while (vnode.parent != vnode) {
            Node<V> temp = vnode.parent;
            vnode.parent = vnode.parent.parent;
            vnode = temp;
        }
        return vnode.value;
    }

    public void Union(V x, V y) {
        if (!set.containsKey(x)) {
            set.put(x, new Node<>(x));
        }
        if (!set.containsKey(y)) {
            set.put(y, new Node<>(y));
        }

        V xParent = Find(x);
        V yParent = Find(y);
        Node<V> xNode = set.get(xParent);
        Node<V> yNode = set.get(yParent);

        if (xNode.deep > yNode.deep) {
            yNode.parent = xNode;
        } else if (xNode.deep < yNode.deep) {
            xNode.parent = yNode;
        } else {
            yNode.deep++;
            xNode.parent = yNode;
        }
    }

    public boolean isUnion(V x, V y) {
        V xParent = Find(x);
        V yParent = Find(y);
        return Objects.equals(xParent, yParent);
    }
}