并查集解决721账户合并

解决方法：

1. 因为要使用并查集，所以要建立每个邮箱的地址：<邮箱， 索引>
2. 建立并查集 
3. 插入数据，对每个人下面的邮箱，和第一个邮箱做合并
4. 建立root地址对应邮箱同属一个人的集合：<root, List>
5. 组合结果

代码量比较多：

 

import java.util.*;

class Solution {

    private class UnionFind{
        // 节点的祖先节点
        private int []parent;
        // 节点的高度，开始时随机选一个做父亲，父亲的高度越来越高，就变成祖先了
        private int []rank;


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


        // 高度高的是祖先，合并
        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]++;
            }else if(rank[rootX] < rank[rootY]){
                parent[rootX] = rootY;
            }else {
                parent[rootY] = rootX;
            }
        }


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

    public List<List<String>> accountsMerge(List<List<String>> accounts) {

        // 每个邮箱的索引，唯一
        int indexCount = 0;

        // 第一步：因为要使用并查集，所以要建立每个邮箱的地址：<邮箱， 索引>
        Map<String, Integer> indexMap = new HashMap<>();
        for(List<String>account: accounts){
            for(int i=1; i<account.size(); i++){
                if(!indexMap.containsKey(account.get(i))){
                    indexMap.put(account.get(i), indexCount++);
                }
            }
        }

        // 第二步：建立并查集
        UnionFind unionFind = new UnionFind(indexCount+1);

        // 第三步：插入数据，对每个人下面的邮箱，和第一个邮箱做合并
        for(List<String>account: accounts){
            String email = account.get(1);
            int emailIndex = indexMap.get(email);
            for(int i=2; i<account.size(); i++){
                unionFind.union(emailIndex, indexMap.get(account.get(i)));
            }
        }

        // 第四步：建立root地址对应邮箱同属一个人的集合：<root, List>
        Map<Integer, TreeSet<String>> map = new HashMap<>();

        // 建立集合
        for(List<String>account: accounts){
            for(int i=1; i<account.size(); i++){
                int root = unionFind.find(indexMap.get(account.get(i)));
                if(!map.containsKey(root)){
                    TreeSet<String>treeSet = new TreeSet<>();
                    treeSet.add(account.get(i));
                    map.put(root, treeSet);
                }else {
                    TreeSet<String> treeSet = map.get(root);
                    treeSet.add(account.get(i));
                }
            }
        }

        // 第五步，组合数据
        Set<Integer> set = new HashSet<>();
        List<List<String>> res = new LinkedList<>();

        for(List<String>account: accounts){
            String name = account.get(0);
            int root = unionFind.find(indexMap.get(account.get(1)));
            if(!set.contains(root)){
                TreeSet<String> treeSet = map.get(root);

                LinkedList<String> ls = new LinkedList<>();
                ls.addLast(name);

                for(String email: treeSet){
                    ls.addLast(email);
                }

                ((LinkedList<List<String>>) res).addLast(ls);
                set.add(root);
            }
        }
        return res;
    }
}