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

Author: Botao Xiao

README.md

@@ -618,6 +618,14 @@
 * [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
+* [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)
+* [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)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/10. Regular Expression Matching.md

@@ -154,4 +154,36 @@ class Solution {
         return c1 == c2 || c2 == '.';
     }
 }
-```
+```
+
+### Fourth time
+* Method 1: dp
+  ```Java
+  class Solution {
+      public boolean isMatch(String s, String p) {
+          char[] sArr = s.toCharArray();
+          char[] pArr = p.toCharArray();
+          int sLen = sArr.length, pLen = pArr.length;
+          boolean[][] dp = new boolean[sLen + 1][pLen + 1];
+          dp[0][0] = true;
+          for(int i = 1; i <= pLen; i++){
+              if(pArr[i - 1] == '*')
+                  dp[0][i] |= (i - 2 >= 0 ? dp[0][i - 2]: false);
+          }
+          for(int i = 1; i <= sLen; i++){
+              for(int j = 1; j <= pLen; j++){
+                  if(match(sArr[i - 1], pArr[j - 1])) dp[i][j] |= dp[i - 1][j - 1];
+                  else if(pArr[j - 1] == '*'){
+                      dp[i][j] |= (j - 2 >= 0 ? dp[i][j - 2]: false);
+                      if(j > 1 && match(sArr[i - 1], pArr[j - 2]))
+                          dp[i][j] |= dp[i - 1][j];
+                  }
+              }
+          }
+          return dp[sLen][pLen];
+      }
+      private boolean match(char a, char b){
+          return a == b || b == '.';
+      }
+  }
+  ```

leetcode/133. Clone Graph.md

@@ -56,7 +56,7 @@ public class Solution {
 ```
 
 ### 二刷
-1. 参考了一刷，使用BFS。
+1. 参考了一刷，使用DFS。
 ```Java
 /**
  * Definition for undirected graph.
@@ -83,3 +83,44 @@ public class Solution {
     }
 }
 ```
+
+### Third Time
+* Method 1: dfs + map
+  * Step 1: Check is current node is empty.
+  * Step 2: Check if cached.
+  * Step 3: Create a new node and save it into map.
+  * Step 4: Use dfs to copy all its neighbours.
+  ```Java
+  /*
+  // Definition for a Node.
+  class Node {
+      public int val;
+      public List<Node> neighbors;
+      public Node() {}
+      public Node(int _val,List<Node> _neighbors) {
+          val = _val;
+          neighbors = _neighbors;
+      }
+  };
+  */
+  class Solution {
+      private Map<Integer, Node> map;
+      public Node cloneGraph(Node node) {
+          map = new HashMap<>();
+          return dfs(node, node.val);
+      }
+      private Node dfs(Node node, int num){
+          if(node == null) return null;
+          else if(map.containsKey(num)) return map.get(num);
+          else{
+              List<Node> neighbours = new ArrayList<>();
+              Node cur = new Node(num, neighbours);
+              map.put(num, cur);
+              for(Node neighbour : node.neighbors){
+                  neighbours.add(dfs(neighbour, neighbour.val));
+              }
+              return cur;
+          }
+      }
+  }
+  ```

leetcode/138. Copy List with Random Pointer.md

@@ -125,4 +125,46 @@ public class Solution {
         return result.next;
     }
 }
-```
+```
+
+### Third Time
+* Method 1: dfs + map
+  * This question is a graph question, for each nodes, we can consider its next and random as two neighbours.
+  * Related question [133. Clone Graph](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/133.%20Clone%20Graph.md)
+  ```Java
+  /*
+  // Definition for a Node.
+  class Node {
+      public int val;
+      public Node next;
+      public Node random;
+
+      public Node() {}
+
+      public Node(int _val,Node _next,Node _random) {
+          val = _val;
+          next = _next;
+          random = _random;
+      }
+  };
+  */
+  class Solution {
+      private Map<Integer, Node> map;
+      public Node copyRandomList(Node head) {
+          map = new HashMap<>();
+          return head == null ? null: dfs(head, head.val);
+      }
+      private Node dfs(Node node, int num){
+          if(node == null) return null;
+          else if(map.containsKey(num)) return map.get(num);
+          else{
+              Node cur = new Node();
+              cur.val = num;
+              map.put(num, cur);
+              cur.next = node.next == null ? null: dfs(node.next, node.next.val);
+              cur.random = node.random == null ? null: dfs(node.random, node.random.val);
+              return cur;
+          }
+      }
+  }
+  ```

leetcode/200. Number of Islands.md

@@ -132,3 +132,91 @@ class Solution {
     }
 }
 ```
+
+### Third Time
+* Method 1: dfs
+  ```Java
+  class Solution {
+      private int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+      private int height;
+      private int width;
+      public int numIslands(char[][] grid) {
+          if(grid == null || grid.length == 0 || grid[0].length == 0) return 0;
+          this.height = grid.length;
+          this.width = grid[0].length;
+          int res = 0;
+          for(int i = 0; i < height; i++){
+              for(int j = 0; j < width; j++){
+                  if(grid[i][j] == '0') continue;
+                  dfs(grid, i, j);
+                  res++;
+              }
+          }
+          return res;
+      }
+      private void dfs(char[][] grid, int row, int col){
+          grid[row][col] = '0';
+          int tx = 0, ty = 0;
+          for(int i = 0; i < 4; i++){
+              tx = row + dir[i][0];
+              ty = col + dir[i][1];
+              if(tx >= 0 && tx < height && ty >= 0 && ty < width && grid[tx][ty] != '0')
+                  dfs(grid, tx, ty);
+          }
+      }
+  }
+  ```
+
+  * Method 2: union-find
+    1. For any single node, we can check its right side node and bottom side node and add them to union find set.
+    2. There are two tricks for optimize union find set:
+      * path compression.
+      * merge using rank.
+    ```Java
+    class Solution {
+        private int[] uf;
+        private static int[][] dir = new int[][]{{0, 1}, {1, 0}};
+        public int numIslands(char[][] grid) {
+            if(grid == null || grid.length == 0 || grid[0].length == 0) return 0;
+            int height = grid.length;
+            int width = grid[0].length;
+            uf = new int[height * width];
+            for(int i = 0; i < height; i++){
+                for(int j = 0; j < width; j++){
+                    if(grid[i][j] == '1')
+                        uf[i * width + j] = i * width + j;
+                    else uf[i * width + j] = -1;
+                }
+            }
+            for(int i = 0; i < height; i++){
+                for(int j = 0; j < width; j++){
+                    if(grid[i][j] == '0') continue;
+                    int tx = 0, ty = 0;
+                    for(int d = 0; d < 2; d++){
+                        tx = i + dir[d][0];
+                        ty = j + dir[d][1];
+                        if(tx >= 0 && tx < height && ty >= 0 && ty < width && grid[tx][ty] == '1'){
+                            union(i * width + j, tx * width + ty);
+                        }
+                    }
+                }
+            }
+            int res = 0;
+            for(int i = 0; i < uf.length; i++){
+                if(uf[i] == i) res++;
+            }
+            return res;
+        }
+        private void union(int i, int j){
+            int p = find(i);
+            int q = find(j);
+            uf[p] = q;
+        }
+        private int find(int i){
+            if(uf[i] != i){
+                uf[i] = find(uf[i]);
+            }
+            return uf[i];
+        }
+    }
+    ```

leetcode/44. Wildcard Matching.md

@@ -88,4 +88,33 @@ class Solution {
         return a == b || b == '?';
     }
 }
-```
+```
+
+### Third Time
+* Method 1: dp
+  ```Java
+  class Solution {
+      public boolean isMatch(String s, String p) {
+          char[] sArr = s.toCharArray();
+          char[] pArr = p.toCharArray();
+          int sLen = sArr.length, pLen = pArr.length;
+          boolean[][] dp = new boolean[sLen + 1][pLen + 1];
+          dp[0][0] = true;
+          for(int i = 1; i <= pLen; i++)
+              if(pArr[i - 1] == '*')
+                  dp[0][i] = dp[0][i - 1];
+          for(int i = 1; i <= sLen; i++){
+              for(int j = 1; j <= pLen; j++){
+                  if(match(sArr[i - 1], pArr[j - 1])) dp[i][j] |= dp[i - 1][j - 1];
+                  else if(pArr[j - 1] == '*'){
+                      dp[i][j] |= dp[i - 1][j] || dp[i - 1][j - 1] || dp[i][j - 1];
+                  }
+              }
+          }
+          return dp[sLen][pLen];
+      }
+      private boolean match(char a, char b){
+          return a == b || b == '?';
+      }
+  }
+  ```

leetcode/547. Friend Circles.md

@@ -0,0 +1,101 @@
+## 547. Friend Circles
+
+### Question
+There are N students in a class. Some of them are friends, while some are not. Their friendship is transitive in nature. For example, if A is a direct friend of B, and B is a direct friend of C, then A is an indirect friend of C. And we defined a friend circle is a group of students who are direct or indirect friends.
+
+Given a N*N matrix M representing the friend relationship between students in the class. If M[i][j] = 1, then the ith and jth students are direct friends with each other, otherwise not. And you have to output the total number of friend circles among all the students.
+
+```
+Example 1:
+Input:
+[[1,1,0],
+ [1,1,0],
+ [0,0,1]]
+Output: 2
+Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
+The 2nd student himself is in a friend circle. So return 2.
+Example 2:
+Input:
+[[1,1,0],
+ [1,1,1],
+ [0,1,1]]
+Output: 1
+Explanation:The 0th and 1st students are direct friends, the 1st and 2nd students are direct friends,
+so the 0th and 2nd students are indirect friends. All of them are in the same friend circle, so return 1.
+```
+
+Note:
+* N is in range [1,200].
+* M[i][i] = 1 for all students.
+* If M[i][j] = 1, then M[j][i] = 1.
+
+### Solution:
+* Method 1:Union find
+  ```Java
+  class Solution {
+      private int[] uf;
+      private int num;
+      public int findCircleNum(int[][] M) {
+          if(M == null || M.length == 0) return 0;
+          this.num = M.length;
+          uf = new int[num];
+          for(int i = 0; i < num; i++) uf[i] = i;
+          for(int i = 0; i < num; i++){
+              for(int j = i + 1; j < num; j++){
+                  if(M[i][j] == 1){ //means student i and j are friends
+                      union(i, j);
+                  }
+              }
+          }
+          int res = 0;
+          for(int i = 0; i < uf.length; i++){
+              if(uf[i] == i)
+                  res++;
+          }
+          return res;
+      }
+      private void union(int i, int j){
+          int p = find(i);
+          int q = find(j);
+          if(p != q){
+              uf[p] = q;
+          }
+      }
+      private int find(int i){
+          if(uf[i] != i){
+              uf[i] = find(uf[i]);
+          }
+          return uf[i];
+      }
+  }
+  ```
+
+* Method 2: DFS
+  * Once we get a not visited student, we set all its friends(including himself) as visited.
+  ```Java
+  class Solution {
+      private boolean[] visited;
+      private int num;
+      private int res;
+      public int findCircleNum(int[][] M) {
+          if(M == null || M.length == 0) return 0;
+          this.num = M.length;
+          this.visited = new boolean[num];
+          for(int i = 0; i < num; i++){
+              if(!visited[i]){
+                  dfs(M, i);
+                  res++;
+              }
+          }
+          return res;
+      }
+      private void dfs(int[][] M, int i){
+          visited[i] = true;
+          for(int j = 0; j < num; j++){
+              if(!visited[j] && j != i && M[i][j] == 1){
+                  dfs(M, j);
+              }
+          }
+      }
+  }
+  ```