[Function add]

1. Add leetcode solutions with tag graph.

Author: Seanforfun

README.md

@@ -618,7 +618,7 @@
 * [576. Out of Boundary Paths](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/576.%20Out%20of%20Boundary%20Paths.md)
 * [935. Knight Dialer](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/935.%20Knight%20Dialer.md)
 
-#### Graph
+### Graph
 * [133. Clone Graph](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/133.%20Clone%20Graph.md)
 * [138. Copy List with Random Pointer](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/138.%20Copy%20List%20with%20Random%20Pointer.md)
 * [200. Number of Islands](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/200.%20Number%20of%20Islands.md)

leetcode/721. Accounts Merge.md

@@ -0,0 +1,78 @@
+## 721. Accounts Merge
+
+### Question:
+Given a list accounts, each element accounts[i] is a list of strings, where the first element accounts[i][0] is a name, and the rest of the elements are emails representing emails of the account.
+
+Now, we would like to merge these accounts. Two accounts definitely belong to the same person if there is some email that is common to both accounts. Note that even if two accounts have the same name, they may belong to different people as people could have the same name. A person can have any number of accounts initially, but all of their accounts definitely have the same name.
+
+After merging the accounts, return the accounts in the following format: the first element of each account is the name, and the rest of the elements are emails in sorted order. The accounts themselves can be returned in any order.
+
+```
+Example 1:
+
+Input: 
+accounts = [["John", "johnsmith@mail.com", "john00@mail.com"], ["John", "johnnybravo@mail.com"], ["John", "johnsmith@mail.com", "john_newyork@mail.com"], ["Mary", "mary@mail.com"]]
+Output: [["John", 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com'],  ["John", "johnnybravo@mail.com"], ["Mary", "mary@mail.com"]]
+Explanation: 
+The first and third John's are the same person as they have the common email "johnsmith@mail.com".
+The second John and Mary are different people as none of their email addresses are used by other accounts.
+We could return these lists in any order, for example the answer [['Mary', 'mary@mail.com'], ['John', 'johnnybravo@mail.com'], 
+['John', 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com']] would still be accepted.
+```
+
+Note:
+* The length of accounts will be in the range [1, 1000].
+* The length of accounts[i] will be in the range [1, 10].
+* The length of accounts[i][j] will be in the range [1, 30].
+
+
+### Solution:
+* Method 1: Union find set beats 94%
+    ```Java
+   class Solution {
+        public List<List<String>> accountsMerge(List<List<String>> accounts) {
+            Map<String, String> owner = new HashMap<>();    // key: e-mail value: name -> records which user it belongs to.
+            Map<String, String> parent = new HashMap<>();   // key: email value: email
+            Map<String, TreeSet<String>> uf = new HashMap<>();
+            // Step 1: Initialization
+            for(List<String> account : accounts){
+                for(int i = 1; i < account.size(); i++){
+                    parent.put(account.get(i), account.get(i)); // each e-mails was initialized to point to themselves.
+                    owner.put(account.get(i), account.get(0));  // set onwer of each e-mail.
+                }
+            }
+            // Step 2: Merge each lines
+            for(List<String> account : accounts){
+                String root = find(account.get(1), parent); // find the root e-mail for the first email and this one will be the root for this account.
+                for(int i = 2; i < account.size(); i++){
+                    parent.put(find(account.get(i), parent), root); // find root for rest e-mails and merge them to the root.
+                }
+            }
+            // Step 3: Add to uf.(Actually merge different lines)
+            for(List<String> account : accounts){
+                String root = find(account.get(1), parent); //// find the root e-mail for the first email.
+                if(!uf.containsKey(root)) uf.put(root, new TreeSet<String>());
+                for(int i = 1; i < account.size(); i++)
+                    uf.get(root).add(account.get(i)); // Add all emails in this account to uf.
+            }
+            // Step 4: Create result List.
+            List<List<String>> result = new ArrayList<>();
+            for(String key : uf.keySet()){
+                List<String> temp = new ArrayList<>();
+                temp.add(owner.get(uf.get(key).first()));   // first add the username.
+                temp.addAll(uf.get(key)); // Add all emails to the list.
+                result.add(temp);
+            }
+            return result;
+        }
+        private String find(String s, Map<String, String> map){
+            if(!map.get(s).equals(s)){
+                map.put(s, find(map.get(s), map));
+            }
+            return map.get(s);
+        }
+    }
+    ```
+
+### Reference
+1. [[Java/C++] Union Find](https://leetcode.com/problems/accounts-merge/discuss/109157/JavaC++-Union-Find)

leetcode/886. Possible Bipartition.md

@@ -0,0 +1,123 @@
+## 886. Possible Bipartition
+
+### Question:
+Given a set of N people (numbered 1, 2, ..., N), we would like to split everyone into two groups of any size.
+
+Each person may dislike some other people, and they should not go into the same group. 
+
+Formally, if dislikes[i] = [a, b], it means it is not allowed to put the people numbered a and b into the same group.
+
+Return true if and only if it is possible to split everyone into two groups in this way.
+
+```
+Example 1:
+
+Input: N = 4, dislikes = [[1,2],[1,3],[2,4]]
+Output: true
+Explanation: group1 [1,4], group2 [2,3]
+
+Example 2:
+
+Input: N = 3, dislikes = [[1,2],[1,3],[2,3]]
+Output: false
+
+Example 3:
+
+Input: N = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]
+Output: false
+```
+
+Note:
+* 1 <= N <= 2000
+* 0 <= dislikes.length <= 10000
+* 1 <= dislikes[i][j] <= N
+* dislikes[i][0] < dislikes[i][1]
+* There does not exist i != j for which dislikes[i] == dislikes[j].
+
+### Solution:
+![Imgur](https://i.imgur.com/8aPdzPj.png)
+* Method 1: dfs + bopartite
+    * we use the dfs to color the graph.
+    * Current node is 1, and we need to color their neighbours to -1, and keep coloring.
+    * If one node's color is filled and different from current color, this question cannot be solved.
+    ```Java
+   class Solution {
+        private Map<Integer, List<Integer>> graph;
+        private int[] visited;
+        public boolean possibleBipartition(int N, int[][] dislikes) {
+            if(N == 0 || dislikes.length == 0) return true;
+            graph = new HashMap<>();
+            for(int[] dislike : dislikes){
+                List<Integer> temp = graph.containsKey(dislike[0]) ? graph.get(dislike[0]): new ArrayList<>();
+                temp.add(dislike[1]);
+                graph.put(dislike[0], temp);
+                temp = graph.containsKey(dislike[1]) ? graph.get(dislike[1]): new ArrayList<>();
+                temp.add(dislike[0]);
+                graph.put(dislike[1], temp);
+            }
+            visited = new int[N + 1];
+            for(int i = 0; i < N; i++){
+                if(visited[i] == 0){
+                    if(!dfs(i, 1)) return false;
+                }
+            }
+            return true;
+        }
+        private boolean dfs(int node, int color){
+            if(visited[node] != 0 && visited[node] != color) return false;
+            if(visited[node] == color) return true;
+            visited[node] = color;
+            List<Integer> neighbours = graph.get(node);
+            if(neighbours == null) return true;
+            for(Integer neighbour : neighbours){
+                if(!dfs(neighbour, -color)) return false;
+            }
+            return true;
+        }
+    }
+    ```
+
+* Method 2: bfs
+    * For all initialized node, we set it to 1 and add to queue.
+    * for all neighbours, we check their neighbours color, if any one of them equals current one, return false.
+    * Otherwise, we set it to -currentColor and save it to the queue.
+    * Finally return true;
+    ```Java
+    class Solution {
+        public boolean possibleBipartition(int N, int[][] dislikes) {
+            Map<Integer, List<Integer>> graph = new HashMap<>();
+            for(int[] dislike : dislikes){
+                List<Integer> temp = graph.containsKey(dislike[0]) ? graph.get(dislike[0]): new ArrayList<>();
+                temp.add(dislike[1]);
+                graph.put(dislike[0], temp);
+                temp = graph.containsKey(dislike[1]) ? graph.get(dislike[1]): new ArrayList<>();
+                temp.add(dislike[0]);
+                graph.put(dislike[1], temp);
+            }
+            Queue<Integer> queue = new LinkedList<>();
+            int[] visited = new int[N + 1];
+            for(int i = 0; i < N; i++){
+                if(visited[i] == 0){
+                    visited[i] = 1;
+                    queue.offer(i);
+                    while(!queue.isEmpty()){
+                        int cur = queue.poll();
+                        List<Integer> temp = graph.get(cur);
+                        if(temp == null) continue;
+                        for(Integer next : temp){
+                            if(visited[next] == visited[cur]) return false;
+                            if(visited[next] == 0){
+                                visited[next] = -visited[cur];
+                                queue.offer(next);
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+    }
+    ```
+
+### Reference
+1. [花花酱 LeetCode 886. Possible Bipartition](https://zxi.mytechroad.com/blog/graph/leetcode-886-possible-bipartition/)

leetcode/952. Largest Component Size by Common Factor.md

@@ -0,0 +1,76 @@
+## 952. Largest Component Size by Common Factor
+
+### Question:
+Given a non-empty array of unique positive integers A, consider the following graph:
+* There are A.length nodes, labelled A[0] to A[A.length - 1];
+* There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
+
+Return the size of the largest connected component in the graph.
+
+```
+Example 1:
+
+Input: [4,6,15,35]
+Output: 4
+
+Example 2:
+
+Input: [20,50,9,63]
+Output: 2
+
+Example 3:
+
+Input: [2,3,6,7,4,12,21,39]
+Output: 8
+```
+
+Note:
+* 1 <= A.length <= 20000
+* 1 <= A[i] <= 100000
+
+### Solution:
+* Method 1: Union find set
+    ```Java
+   class Solution {
+        private int[] uf;
+        public int largestComponentSize(int[] A) {
+            if(A == null || A.length == 0) return 0;
+            int max = A[0];
+            for(int i = 1; i < A.length; i++) max = Math.max(max, A[i]);
+            this.uf = new int[max + 1];
+            for(int i = 0; i < uf.length; i++) this.uf[i] = i;
+            // For every number, find their factor and add to uf.
+            for(int i = 0; i < A.length; i++){
+                for(int j = 2; j <= (int)Math.sqrt(A[i]); j++){
+                    if(A[i] % j == 0){
+                        union(A[i], j);
+                        union(A[i], A[i] / j);
+                    }
+                }
+            }
+            Map<Integer, Integer> map = new HashMap<>();
+            int res = 1;
+            for(int i = 0; i < A.length; i++){
+                int root = find(A[i]);
+                int cur = map.containsKey(root) ? map.get(root): 0;
+                map.put(root, ++cur);
+                res = Math.max(res, cur);
+            }
+            return res;
+        }
+        private void union(int i, int j){
+            int p = find(i);
+            int q = find(j);
+            uf[p] = q;
+        }
+        private int find(int j){
+            if(uf[j] != j){
+                uf[j] = find(uf[j]);
+            }
+            return uf[j];
+        }
+    }
+    ```
+   
+### Reference
+1. [花花酱 LeetCode 952. Largest Component Size by Common Factor](https://zxi.mytechroad.com/blog/graph/leetcode-952-largest-component-size-by-common-factor/)

leetcode/990. Satisfiability of Equality Equations.md

@@ -0,0 +1,83 @@
+## 990. Satisfiability of Equality Equations
+
+### Question:
+Given an array equations of strings that represent relationships between variables, each string equations[i] has length 4 and takes one of two different forms: "a==b" or "a!=b".  Here, a and b are lowercase letters (not necessarily different) that represent one-letter variable names.
+
+Return true if and only if it is possible to assign integers to variable names so as to satisfy all the given equations.
+
+```
+Example 1:
+
+Input: ["a==b","b!=a"]
+Output: false
+Explanation: If we assign say, a = 1 and b = 1, then the first equation is satisfied, but not the second.  There is no way to assign the variables to satisfy both equations.
+
+Example 2:
+
+Input: ["b==a","a==b"]
+Output: true
+Explanation: We could assign a = 1 and b = 1 to satisfy both equations.
+
+Example 3:
+
+Input: ["a==b","b==c","a==c"]
+Output: true
+
+Example 4:
+
+Input: ["a==b","b!=c","c==a"]
+Output: false
+
+Example 5:
+
+Input: ["c==c","b==d","x!=z"]
+Output: true
+```
+
+Note:
+* 1 <= equations.length <= 500
+* equations[i].length == 4
+* equations[i][0] and equations[i][3] are lowercase letters
+* equations[i][1] is either '=' or '!'
+* equations[i][2] is '='
+
+
+### Solution:
+* Method 1: Union find set beats 100%
+    ```Java
+   class Solution {
+        private static final char EQ = '=';
+        private static final char NOT_EQ = '!';
+        private char[] uf;
+        public boolean equationsPossible(String[] equations) {
+            this.uf = new char[26];
+            for(int i = 0; i < 26; i++) uf[i] = (char)(i + 'a');
+            for(int i = 0; i < equations.length; i++){
+                String eq = equations[i];
+                if(eq.charAt(1) == EQ){ // Add to union find set
+                    union(eq.charAt(0), eq.charAt(3));
+                }
+            }
+            for(int i = 0; i < equations.length; i++){
+                String eq = equations[i];
+                if(eq.charAt(1) == NOT_EQ){
+                    char a = find(eq.charAt(0));
+                    char b = find(eq.charAt(3));
+                    if(a == b) return false;
+                }
+            }
+            return true;
+        }
+        private char find(char c){
+            if(c != uf[c - 'a']){
+                uf[c - 'a'] = find(uf[c - 'a']);
+            }
+            return uf[c - 'a'];
+        }
+        private void union(char a, char b){
+            char p = find(a);
+            char q = find(b);
+            uf[p - 'a'] = q;
+        }
+    }
+    ```