2022.7.30-----leetcode.952

 public int largestComponentSize(int[] nums) {
        int m = Arrays.stream(nums).max().getAsInt();//找到最大值
        UFSets uf = new UFSets(m + 1);
        for (int num : nums) {
            //对每个数分解因数，将他们放到一个集合中
            for (int i = 2; i * i <= num; i++) {
                if (num % i == 0) {
                    uf.union(num, i);
                    uf.union(num, num / i);
                }
            }
        }
        int[] counts = new int[m + 1];
        int ans = 0;
        for (int num : nums) {
            int root = uf.find(num);//找到每个数所在的集合
            counts[root]++;//对应集合数量+1
            ans = Math.max(ans, counts[root]);
        }
        return ans;
    }


    class UFSets<E> {
    private int[] group;//存储下标的父节点
    private int n;//分组个数
    private int[] size;//以下标为根的树的节点个数
    public UFSets(int n) {
        this.n = n;
        this.group=new int[n];
        //初始化,每个节点各为一组
        for (int i = 0; i < n; i++) {
            group[i]=i;
        }
        this.size=new int[n];
        Arrays.fill(size,1);
    }
    //获取分组个数
    public int count(){
        return n;
    }
    //查询元素所在分组
    public int find(int e){
        while (true){
            if(e==group[e])
                return e;
            e=group[e];
        }
    }
    //查询两个元素是否在同一组
    public boolean isConnected(int p,int q){
        return find(p)==find(q);
    }
    //将两个元素的分组合并
    public void union(int p,int q){
        if(!isConnected(p,q)){
            int proot=find(p);
            int qroot=find(q);
            if(size[proot]<size[qroot]){
                group[proot]=qroot;
                size[qroot]+=size[proot];
            } else {
                group[qroot] = proot;
                size[proot]+=size[qroot];
            }
            n--;
        }
    }
}