Union Find - 20181102 - 20181105

Union Find:

589. Connecting Graph

 public class ConnectingGraph {
     //父节点数组
     private int[] father = null;

     /*
     * @param n: An integer
     */
     public ConnectingGraph(int n) {
         // do intialization if necessary
         father = new int[n + 1];
         for (int i = 1; i <= n; i++) {
             father[i] = i;
         }
     }

     /*
      * @param a: An integer
      * @param b: An integer
      * @return: nothing
      */
     public void connect(int a, int b) {
         // write your code here
         int root_a = find(a);
         int root_b = find(b);
         if (root_a == root_b) {
             return;
         }
         father[root_a] = root_b;
     }

     /*
      * @param a: An integer
      * @param b: An integer
      * @return: A boolean
      */
     public boolean query(int a, int b) {
         // write your code here
         return find(a) == find(b);
     }

     //union find 主要逻辑,实现找到每个节点的父节点，同时把寻找父节点的路径子节点都直接链接到root节点下
     //为了减少记录path的空间分配，可以每次将路径中子节点指向父节点的下一个节点，同样可以实现路径压缩
     public int find(int a) {
         if (father[a] == a) {
             return a;
         }
         int i = a;
         while (father[i] != i) {
             int b = father[i];
             father[i] = father[b];
             i = b;
         }
         return i;
     }
 }

590. Connecting Graph II

 public class ConnectingGraph2 {
     private int[] father = null;
     private int[] size = null;

     /*
     * @param n: An integer
     */
     public ConnectingGraph2(int n) {
         // do intialization if necessary
         father = new int[n + 1];
         size = new int[n+1];
         for (int i = 1; i <= n; i++) {
             father[i] = i;
             size[i] = 1;
         }
     }

     /*
      * @param a: An integer
      * @param b: An integer
      * @return: nothing
      */
     public void connect(int a, int b) {
         // write your code here
         int root_a = find(a);
         int root_b = find(b);
         if (root_a != root_b) {
             father[root_a] = root_b;
             size[root_b] += size[root_a];
         }
     }

     /*
      * @param a: An integer
      * @return: An integer
      */
     public int query(int a) {
         // write your code here
         int root_a = find(a);
         return size[root_a];
     }

     public int find(int a) {
         if (father[a] == a) {
             return a;
         }

         Set<Integer> path = new HashSet<>();
         int i = a;
         while (father[i] != i) {
             path.add(i);
             i = father[i];
         }
         for (int num : path) {
             father[num] = i;
         }

         return i;

     }
 }

591. Connecting Graph III

 public class ConnectingGraph3 {
     /**
      * @param a: An integer
      * @param b: An integer
      * @return: nothing
      */
     private int[] father = null;
     private int count = 0;

     public ConnectingGraph3(int n) {
         father = new int[n + 1];
         for (int i = 1; i <= n; i++) {
             father[i] = i;
         }
         count = n;
     }

     public void connect(int a, int b) {
         // write your code here
         int root_a = find(a);
         int root_b = find(b);
         if (root_a != root_b) {
             father[root_a] = root_b;
             count--;
         }
     }

     /**
      * @return: An integer
      */
     public int query() {
         // write your code here
         return count;
     }

     public int find(int a) {
         if (father[a] == a) {
             return a;
         }
         int i = a;
         while (father[i] != i) {
             int b = father[i];
             father[i] = father[b];
             i = b;
         }
         return i;
     }
 }

1070. Accounts Merge(二刷复习)

 public class Solution {
     /**
      * @param accounts: List[List[str]]
      * @return: return a List[List[str]]
      */
     //integer对应accounts的index
     Map<Integer, Integer> father = new HashMap<>();

     public List<List<String>> accountsMerge(List<List<String>> accounts) {
         // write your code here
         List<List<String>> res = new ArrayList<>();
         if (accounts == null || accounts.size() == 0) {
             return res;
         }
         Map<String, List<Integer>> emailToIds = buildEmailToIds(accounts);
         for (Map.Entry<String, List<Integer>> entry : emailToIds.entrySet()) {
             List<Integer> ids = entry.getValue();
             if (ids != null && ids.size() != 0) {
                 for (int i = 0; i < ids.size(); i++) {
                     union(ids.get(i), ids.get(0));
                 }
             }
         }

         Map<Integer, Set<String>> idToEmails = buildIdToEmails(accounts);
         for (Map.Entry<Integer, Set<String>> entry : idToEmails.entrySet()) {
             List<String> mergeList = new ArrayList<>();
             List<String> accountList = new ArrayList<>(entry.getValue());
             Collections.sort(accountList);
             String user = accounts.get(entry.getKey()).get(0);
             mergeList.add(user);
             mergeList.addAll(accountList);
             res.add(mergeList);
         }

         return res;
     }

     public Map<String, List<Integer>> buildEmailToIds(List<List<String>> accounts) {
         Map<String, List<Integer>> res = new HashMap<>();
         for (int i = 0; i < accounts.size(); i++) {
             if (accounts.get(i) == null || accounts.get(i).size() <= 1) {
                 continue;
             }
             father.put(i, i);
             List<String> emails = accounts.get(i);
             for (int j = 1; j < emails.size(); j++) {
                 List<Integer> ids = res.get(emails.get(j));
                 if (ids == null) {
                     ids = new ArrayList<>();
                 }
                 ids.add(i);
                 res.put(emails.get(j), ids);
             }
         }
         return res;
     }

     public Map<Integer, Set<String>> buildIdToEmails(List<List<String>> accounts) {
         Map<Integer, Set<String>> idToEmails = new HashMap<>();
         for (int i = 0; i < accounts.size(); i++) {
             int root_id = find(i);
             Set<String> emails = idToEmails.get(root_id);
             if (emails == null) {
                 emails = new HashSet<>();
             }
             for (int j = 1; j < accounts.get(i).size(); j++) {
                 emails.add(accounts.get(i).get(j));
             }
             idToEmails.put(root_id, emails);
         }
         return idToEmails;
     }

     public void union(int a, int b) {
         int root_a = find(a);
         int root_b = find(b);
         if (root_a != root_b) {
             father.put(root_a, root_b);
         }
     }

     public int find(int a) {
         if (father.get(a) == a) {
             return a;
         }
         Set<Integer> path = new HashSet<>();
         int i = a;
         while (father.get(i) != i) {
             path.add(i);
             i = father.get(i);
         }
         for (int num : path) {
             father.put(num, i);
         }
         return i;
     }

 }