并查集解决1584连接所有点的最小费用

并查集的题总是那么多的代码，还好做出来了😊 

import java.util.*;

class Solution{

    private class UnionFind{
        // 节点的祖先节点
        private int []parent;

        // 初始化，自己是自己的祖先
        public UnionFind(int n){
            this.parent = new int[n];
            for(int i=0; i<n; i++){
                this.parent[i] = i;
            }
        }

        // 高度高的是祖先，合并
        public void union(int x, int y){
            int rootX = find(x);
            int rootY = find(y);
            if(rootX == rootY){
                return;
            }
            parent[rootX] = rootY;
        }

        // 找祖先
        public int find(int x){
            if(x != parent[x]){
                parent[x] = find(parent[x]);
            }
            return parent[x];
        }
    }

    class Point implements Comparable<Point>{
        int index1;
        int index2;
        int distance;

        public Point(int index1, int index2, int distance) {
            this.index1 = index1;
            this.index2 = index2;
            this.distance = distance;
        }

        @Override
        public int compareTo(Point o) {
            if(this.distance < o.distance){
                return -1;
            }else if(this.distance == o.distance){
                return 0;
            }else {
                return 1;
            }
        }
    }

    public int minCostConnectPoints(int[][] points) {

        int res = 0;
        List<Point> ls = new LinkedList<>();
        for(int i=0; i<points.length; i++){
            for(int j=i+1; j<points.length; j++){
                if(i == j){
                    continue;
                }
                int distance = Math.abs(points[i][0] - points[j][0]) + Math.abs(points[i][1] - points[j][1]);
                Point point = new Point(i, j, distance);
                ((LinkedList<Point>) ls).addLast(point);
            }
        }

        Collections.sort(ls);

        UnionFind unionFind = new UnionFind(points.length);

        Map<Integer, Set<Integer>> map = new HashMap<>();
        for(Point point: ls){
            // 从并查集中找当前index是否可达另一个index，不可达则加，否则略过
            int root = unionFind.find(point.index1);
            int root2 = unionFind.find(point.index2);

            // 说明在一个集合中
            if(root == root2 && (map.containsKey(root) || map.containsKey(root2))){
                continue;
            }

            // 说明point.index2不曾出现过
            if(map.containsKey(root) && !map.containsKey(root2)){
                Set<Integer> set = map.get(root);
                set.add(point.index2);
                unionFind.union(point.index2, root);
                res += point.distance;
            }else if(map.containsKey(root2) && !map.containsKey(root)){
                Set<Integer> set = map.get(root2);
                set.add(point.index1);
                unionFind.union(point.index1, root2);
                res += point.distance;
            }else if(map.containsKey(root) && map.containsKey(root2)){
                Set<Integer> set = map.get(root);
                Set<Integer> set1 = map.get(root2);
                for(int data: set1){
                    set.add(data);
                }
                map.remove(root2);
                unionFind.union(root2, root);
                res += point.distance;
            }else if(!map.containsKey(root) && !map.containsKey(root2)){
                HashSet<Integer> hashSet = new HashSet<>();
                hashSet.add(point.index2);
                hashSet.add(point.index1);
                unionFind.union(point.index2, point.index1);
                map.put(point.index1, hashSet);
                res += point.distance;
            }
        }
        return res;
    }
}