并查集的运用

import java.util.HashMap;
import java.util.List;
import java.util.Stack;

public class test34 {

    public static class Node<V>{
        V value;

        public Node(V v){
            value =v;
        }
    }

    public static class UnionSet<V> {
        //通过V找节点
        public HashMap<V, Node<V>> nodes;

        //找一个节点的父节点
        public HashMap<Node<V>, Node<V>> parents;

        //只有一个点是某个集合代表点的时候才会记录数值
        public HashMap<Node<V>, Integer> sizeMap;

        //初始化
        public UnionSet(List<V> values) {
            for (V value : values) {
                Node<V> node = new Node<>(value);//建立节点
                nodes.put(value, node);//数据放进nodes表中
                parents.put(node, node);//所有样本的集合开始都是自己，故node的父亲都是自己
                sizeMap.put(node, 1);//每个值在自己的集合都为1，因为自己的集合只有自己一个值
            }
        }

        //从cur开始，一直往上找，找到不能再往上的代表点返回
        public Node<V> findFather(Node<V> cur) {
            Stack<Node<V>> path = new Stack<>();

            while (cur != parents.get(cur)) {
                path.push(cur);
                cur = parents.get(cur);
            }

            while (!path.isEmpty()) {
                parents.put(path.pop(), cur);
            }

            return cur;
        }


        public boolean isSameSet(V a, V b) {
            if (!nodes.containsKey(a) || !nodes.containsKey(b)) {
                return false;
            }
            return findFather(nodes.get(a)) == findFather(nodes.get(b));
        }

        public void union(V a, V b) {
            if (!nodes.containsKey(a) || nodes.containsKey(b)) {
                return;
            }

            Node<V> aHead = findFather(nodes.get(a));
            Node<V> bHead = findFather(nodes.get(b));

            if (aHead != bHead) {
                //拿到两个集合的大小
                int aSetSize = sizeMap.get(aHead);
                int bSetSize = sizeMap.get(bHead);

                //小的挂在大的上
                if (aSetSize >= bSetSize) {
                    parents.put(bHead, aHead);//把bHead的父改成aHead
                    sizeMap.put(aHead, aSetSize + bSetSize);
//新的aHead为一个集合，数值包括aSetSize和bSetSize
                    sizeMap.remove(bHead);//aHead主导着bHead，故bHead删掉
                } else {
                    parents.put(aHead, bHead);
                    sizeMap.put(bHead, aSetSize + bSetSize);
                    sizeMap.remove(aHead);
                }
            }
        }
        
        public int getSetNum(){
            return sizeMap.size();
        }
    }

    
    //如果两个user , a字段一样或者b字段一样或者c字段一样。就认为是一个人
    //请合并users，返回合并后的用户数量
    //例如(1 ， 10 ， 13) (2 ，10 ，37) (300 ，500 ，37)可以认为是一个人
    public static class User{
        public String a;
        public String b;
        public String c;

        public User(String a , String b , String c){
            this.a = a;
            this.b = b;
            this.c = c;
        }
    }
    public static int mergeUsers(List<User> users){
        UnionSet<User> unionFind = new UnionSet(users);

        HashMap<String , User> mapA =new HashMap<>();
        HashMap<String , User> mapB =new HashMap<>();
        HashMap<String , User> mapC =new HashMap<>();

        for(User user: users){
            //如果mapA里有这个字段，那么合并
            if(mapA.containsKey(user.a)){
                unionFind.union(user , mapA.get(user.a));
            }else{//如果没有这个字段，那么就为新字段
                mapA.put(user.a , user);
            }
            //如果mapB里有这个字段，那么合并
            if(mapB.containsKey(user.b)){
                unionFind.union(user , mapB.get(user.b));
            }else{//如果没有这个字段，那么就为新字段
                mapB.put(user.b , user);
            }
            //如果mapC里有这个字段，那么合并
            if(mapC.containsKey(user.c)){
                unionFind.union(user , mapC.get(user.c));
            }else{//如果没有这个字段，那么就为新字段
                mapC.put(user.c , user);
            }
        }
        
        return unionFind.getSetNum();
    }
}