LeetCode - 924 尽量减少恶意软件的传播

class Solution {
    public int minMalwareSpread(int[][] graph, int[] initial) {
        int n = graph.length;//顶点个数
        Arrays.sort(initial);
        UnionFind uf = new UnionFind(n);
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                if(i != j && graph[i][j] == 1)
                   uf.union(i,j);
            }
        }
        Map<Integer,List<Integer>> map = new HashMap<>();
        for(int i = 0;i < initial.length ;i++){
            int root = uf.find(initial[i]);
            map.computeIfAbsent(root, key -> new ArrayList<Integer>()).add(initial[i]);
        }
        int index = -1;
        int size = 0;
        for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
           int root = entry.getKey();
           List<Integer> list = entry.getValue();
           if(list.size() == 1){
               if(uf.size[root] > size || (uf.size[root] == size && list.get(0) < index)){
                    size = uf.size[root];
                    index = list.get(0);
               }
           }
        }
        if(index == -1)
          return initial[0];
        else
          return index;

    }
    public class UnionFind{
        int[] parent;
        int[] rank;
        int[] size;
        public UnionFind(int n){
            parent = new int[n];
            rank = new int[n];
            size = new int[n];
            for(int i = 0;i < n;i++){
                parent[i] = i;
                rank[i] = 1;
                size[i] = 1;
            }
        }
        public int find(int x){
            if(parent[x] != x){
                parent[x] = find(parent[x]);
            }
            return parent[x];
        }
        public boolean isConnect(int x,int y){
            int rootX = find(x);
            int rootY = find(y);
            if(rootX == rootY)
               return true;
            else
               return false;
        }
         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;
                rank[rootY] += 1;
                size[rootY] += size[rootX];
            }
            else if(rank[rootX] > rank[rootY]){
                parent[rootY] = rootX;
                size[rootX] += size[rootY];
            }
            else{
                parent[rootX] = rootY;
                size[rootY] += size[rootX];
            }
        }
    }
}

class Solution {
    int[] copy;
    public int largestComponentSize(int[] nums) {
          int n = nums.length;
          copy = nums;
          Arrays.sort(nums);
          UnionFind uf = new UnionFind(nums[n-1]+1);
          for (int num : nums) {
            double upBound = Math.sqrt(num);
            for (int i = 2; i <= upBound; i++) {
                if (num % i == 0) {
                    uf.union(num, i);
                    uf.union(num, num / i);
                }
            }
          }
          int max = 0;
          for(int i =0;i<n;i++){
              int num = nums[i];
              int root = uf.find(num);
              int size = uf.size[root];
              if(size > max)
                 max = size;
          }
          return max;
    }
     public class UnionFind{
        int[] parent;
        int[] rank;
        int[] size;
        public UnionFind(int n){
            parent = new int[n];
            rank = new int[n];
            size = new int[n];
            for(int i = 0;i < n;i++){
                parent[i] = i;
                //rank[i] = 1;
                //size[i] = 1;
            }
            for(int i = 0;i < copy.length;i++){
                size[copy[i]] = 1;
            }

        }
        public int find(int x){
            if(parent[x] != x){
                parent[x] = find(parent[x]);
            }
            return parent[x];
        }
         public void union(int x,int y){
            int rootX = find(x);
            int rootY = find(y);
            if(rootX == rootY)
               return ;
            parent[rootX] = rootY;
            size[rootY] += size[rootX];
        }
    }
}