[Function add]: 1. Add leetcode solutions with tag graph.

Botao Xiao · Botao Xiao · commit 0014ddb4e90d · 2019-03-26T18:18:12.000-04:00
diff --git a/README.md b/README.md
@@ -619,12 +619,29 @@
 * [935. Knight Dialer](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/935.%20Knight%20Dialer.md)
 
 ### Graph
+#### Clone graph: hashtable + dfs
 * [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)
+#### Grid + Connected Component
 * [200. Number of Islands](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/200.%20Number%20of%20Islands.md)
 * [547. Friend Circles](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/547.%20Friend%20Circles.md)
 * [695. Max Area of Island](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/695.%20Max%20Area%20of%20Island.md)
 * [733. Flood Fill](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/733.%20Flood%20Fill.md)
+* [827. Making A Large Island](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/827.%20Making%20A%20Large%20Island.md)
+* [841. Keys and Rooms](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/841.%20Keys%20and%20Rooms.md)
+#### Topological Sort
+* [207. Course Schedule](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/207.%20Course%20Schedule.md)
+* [210. Course Schedule II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/210.%20Course%20Schedule%20II.md)
+* [802. Find Eventual Safe States](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/802.%20Find%20Eventual%20Safe%20States.md)
+#### Union Find Set / Disjoint Set
+* [399. Evaluate Division](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/399.%20Evaluate%20Division.md)
+* [839. Similar String Groups](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/839.%20Similar%20String%20Groups.md)
+* [952. Largest Component Size by Common Factor](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/952.%20Largest%20Component%20Size%20by%20Common%20Factor.md)
+* [990. Satisfiability of Equality Equations](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/990.%20Satisfiability%20of%20Equality%20Equations.md)
+* [721. Accounts Merge](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/721.%20Accounts%20Merge.md)
+#### Bipartite
+* [785. Is Graph Bipartite?](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/785.%20Is%20Graph%20Bipartite?.md)
+* [886. Possible Bipartition](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/886.%20Possible%20Bipartition.md)
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
diff --git a/leetcode/399. Evaluate Division.md b/leetcode/399. Evaluate Division.md
@@ -6,7 +6,7 @@
 Example:
 Given a / b = 2.0, b / c = 3.0.
 queries are: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ? .
-return [6.0, 0.5, -1.0, 1.0, -1.0 ]. 
+return [6.0, 0.5, -1.0, 1.0, -1.0 ].
 ```
 
 ### Thinking:
@@ -87,4 +87,121 @@ class Solution {
         }
     }
 }
-```
+```
+
+### Second Time
+* Method 1: Union Find Set
+  ```Java
+  class Solution {
+      private static class Node{
+          // node = ratio * parent or node / parent = ratio
+          String parent;
+          double ratio;
+          public Node(String parent, double ratio){
+              this.parent = parent;
+              this.ratio = ratio;
+          }
+      }
+      private static class UF{
+          Map<String, Node> uf = new HashMap<>();
+
+          public Node find(String s){
+              if(!uf.containsKey(s)) return null;
+              Node n = uf.get(s);
+              if(!n.parent.equals(s)){
+                  Node p = find(n.parent);
+                  n.parent = p.parent;
+                  // b = 2 * a && c = 2 * b => c = 2 * 3 * a = 6 * a
+                  n.ratio *= p.ratio;
+              }
+              return n;
+          }
+
+          public void union(String i, String j, double ratio){
+              boolean hasI = uf.containsKey(i);
+              boolean hasJ = uf.containsKey(j);
+              // i / j = ratio => i = j * ratio
+              if(!hasI && !hasJ){
+                  uf.put(i, new Node(j, ratio));
+                  uf.put(j, new Node(j, 1D));
+              }else if(!hasI){
+                  uf.put(i, new Node(j, ratio));
+              }else if(!hasJ){
+                  uf.put(j, new Node(i, 1 / ratio));
+              }else{
+                  Node p = find(i);
+                  Node q = find(j);
+                  p.parent = q.parent;
+                  p.ratio = ratio * q.ratio / p.ratio;
+              }
+          }
+      }
+      public double[] calcEquation(String[][] equations, double[] values, String[][] queries) {
+          UF uf = new UF();
+          for(int i = 0; i < equations.length; i++){
+              uf.union(equations[i][0], equations[i][1], values[i]);
+          }
+          double[] res = new double[queries.length];
+          for(int i = 0; i < res.length; i++){
+              String[] query = queries[i];
+              Node first = uf.find(query[0]);
+              Node second = uf.find(query[1]);
+              if(first == null || second == null || !first.parent.equals(second.parent)){
+                  res[i] = -1D;
+                  continue;
+              }else{
+                  // we want a / b = first.ratio * r / second.ratio * r
+                  res[i] = first.ratio / second.ratio;
+              }
+          }
+          return res;
+      }
+  }
+  ```
+
+  * Method 2: dfs: record all pairs and use dfs to get the result.
+    ```Java
+    class Solution {
+        Map<String, Map<String, Double>> graph;
+        public double[] calcEquation(String[][] equations, double[] values, String[][] queries) {
+            graph = new HashMap<>();
+            for(int i = 0; i < equations.length; i++){
+                // a / b = ratio => a = b * ratio
+                String first = equations[i][0], second = equations[i][1];
+                Map<String, Double> temp = graph.containsKey(first) ? graph.get(first): new HashMap<>();
+                temp.put(second, values[i]);
+                graph.put(first, temp);
+                temp = graph.containsKey(second) ? graph.get(second): new HashMap<>();
+                temp.put(first, 1/ values[i]);
+                graph.put(second, temp);
+            }
+            double[] res = new double[queries.length];
+            for(int i = 0; i < res.length; i++){
+                String first = queries[i][0];
+                String second = queries[i][1];
+                if(!graph.containsKey(first) || !graph.containsKey(second)){
+                    res[i] = -1D;
+                    continue;
+                }else{
+                    res[i] = divide(first, second, new HashSet<>());
+                }
+            }
+            return res;
+        }
+        private double divide(String first, String second, Set<String> visited){
+            if(first.equals(second)) return 1D;
+            else{
+                for(String next : graph.get(first).keySet()){
+                    if(visited.contains(next)) continue;
+                    visited.add(next);
+                    double d = divide(next, second, visited);
+                    if(d > 0) return d * graph.get(first).get(next);
+                }
+                return -1D;
+            }
+        }
+    }
+    ```
+
+### Reference
+1. [花花酱 LeetCode 399. Evaluate Division](http://zxi.mytechroad.com/blog/graph/leetcode-399-evaluate-division/)
diff --git a/leetcode/827. Making A Large Island.md b/leetcode/827. Making A Large Island.md
@@ -0,0 +1,65 @@
+## 827. Making A Large Island
+
+### Question:
+In a 2D grid of 0s and 1s, we change at most one 0 to a 1.
+
+After, what is the size of the largest island? (An island is a 4-directionally connected group of 1s).
+
+```
+Example 1:
+
+Input: [[1, 0], [0, 1]]
+Output: 3
+Explanation: Change one 0 to 1 and connect two 1s, then we get an island with area = 3.
+Example 2:
+
+Input: [[1, 1], [1, 0]]
+Output: 4
+Explanation: Change the 0 to 1 and make the island bigger, only one island with area = 4.
+Example 3:
+
+Input: [[1, 1], [1, 1]]
+Output: 4
+Explanation: Can't change any 0 to 1, only one island with area = 4.
+```
+
+Notes:
+* 1 <= grid.length = grid[0].length <= 50.
+* 0 <= grid[i][j] <= 1.
+
+### Solution:
+* Method 1: dfs AC 16.04%
+  * We check all nodes whose value is 0, we try to change this value from 0 to 1 and record the max area could be reach.
+  ```Java
+  class Solution {
+      private int height, width;
+      private int res = 0;
+      private static int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+      public int largestIsland(int[][] grid) {
+          if(grid == null || grid.length == 0 || grid[0].length == 0) return 0;
+          height = grid.length;
+          width = grid[0].length;
+          for(int i = 0; i < height; i++){
+              for(int j = 0; j < width; j++){
+                  if(grid[i][j] == 0){ //Assume we change the current node from 0 to 1
+                      res = Math.max(dfs(grid, i, j, new boolean[height][width]), res);
+                  }
+              }
+          }
+          return res == 0 ? height * width: res;
+      }
+      private int dfs(int[][] grid, int r, int c, boolean[][] visited){
+          int cur = 1;
+          int tx = 0, ty = 0;
+          visited[r][c] = true;
+          for(int d = 0; d < 4; d++){
+              tx = r + dir[d][0];
+              ty = c + dir[d][1];
+              if(tx >= 0 && tx < height && ty >= 0 && ty < width && grid[tx][ty] == 1 && !visited[tx][ty]){
+                  cur += dfs(grid, tx, ty, visited);
+              }
+          }
+          return cur;
+      }
+  }
+  ```
diff --git a/leetcode/839. Similar String Groups.md b/leetcode/839. Similar String Groups.md
@@ -0,0 +1,83 @@
+## 839. Similar String Groups
+
+### Question
+Two strings X and Y are similar if we can swap two letters (in different positions) of X, so that it equals Y.
+
+For example, "tars" and "rats" are similar (swapping at positions 0 and 2), and "rats" and "arts" are similar, but "star" is not similar to "tars", "rats", or "arts".
+
+Together, these form two connected groups by similarity: {"tars", "rats", "arts"} and {"star"}.  Notice that "tars" and "arts" are in the same group even though they are not similar.  Formally, each group is such that a word is in the group if and only if it is similar to at least one other word in the group.
+
+We are given a list A of strings.  Every string in A is an anagram of every other string in A.  How many groups are there?
+
+```
+Example 1:
+
+Input: ["tars","rats","arts","star"]
+Output: 2
+```
+
+Note:
+* A.length <= 2000
+* A[i].length <= 1000
+* A.length * A[i].length <= 20000
+* All words in A consist of lowercase letters only.
+* All words in A have the same length and are anagrams of each other.
+* The judging time limit has been increased for this question.
+
+### Solution
+* Method 1: Union Find Set
+  ```Java
+  class Solution {
+      private int[] uf;
+      private int[] rank;
+      public int numSimilarGroups(String[] A) {
+          uf = new int[A.length];
+          rank = new int[A.length];
+          for(int i = 0; i < A.length; i++){
+              uf[i] = i;
+          }
+          for(int i = 0; i < A.length; i++){
+              for(int j = i + 1; j < A.length; j++){
+                  if(i == j) continue;
+                  else if(connected(A[i], A[j])){
+                      union(i, j);
+                  }
+              }
+          }
+          int res = 0;
+          for(int i = 0; i < A.length; i++){
+              if(uf[i] == i) res++;
+          }
+          return res;
+      }
+      private int find(int a){
+          if(a != uf[a]){
+              uf[a] = find(uf[a]);
+          }
+          return uf[a];
+      }
+      private void union(int a, int b){
+          int p = find(a);
+          int q = find(b);
+          if(q == p) return;
+          if(rank[p] < rank[q]){
+              uf[p] = q;
+              rank[q] = Math.max(rank[q], rank[p] + 1);
+          }else{
+              uf[q] = p;
+              rank[p] = Math.max(rank[p], rank[q] + 1);
+          }
+      }
+      private boolean connected(String a, String b){
+          if(a.equals(b)) return true;
+          char[] arrA = a.toCharArray();
+          char[] arrB = b.toCharArray();
+          int diff = 0;
+          for(int i = 0; i < arrA.length; i++){
+              if(arrA[i] != arrB[i]) diff++;
+              if(diff > 2) return false;
+          }
+          return diff == 0 || diff == 2;
+      }
+  }
+  ```
diff --git a/leetcode/841. Keys and Rooms.md b/leetcode/841. Keys and Rooms.md
