[Function add]: 1. Add leetcode solutions with tag search and dfs.

Author: Botao Xiao

README.md

@@ -538,6 +538,15 @@
 * [943. Find the Shortest Superstring](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/943.%20Find%20the%20Shortest%20Superstring.md)
 * [996. Number of Squareful Arrays](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/996.%20Number%20of%20Squareful%20Arrays.md)
 
+#### DFS
+* [22. Generate Parentheses](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/22.%20Generate%20Parentheses.md)
+* [301. Remove Invalid Parentheses](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/301.%20Remove%20Invalid%20Parentheses.md)
+* [37. Sudoku Solver](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/37.%20Sudoku%20Solver.md)
+* [51. N-Queens](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/51.%20N-Queens.md)
+* [52. N-Queens II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/52.%20N-Queens%20II.md)
+* [79. Word Search](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/79.%20Word%20Search.md)
+* [[212. Word Search II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/212.%20Word%20Search%20II.md)]
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/212. Word Search II.md

@@ -8,7 +8,7 @@ Each word must be constructed from letters of sequentially adjacent cell, where
 ```
 Example:
 
-Input: 
+Input:
 words = ["oath","pea","eat","rain"] and board =
 [
   ['o','a','a','n'],
@@ -156,4 +156,46 @@ class Solution {
         return false;
     }
 }
-```
+```
+
+### Third time
+```Java
+class Solution {
+    public List<String> findWords(char[][] board, String[] words) {
+        List<String> result = new ArrayList<>();
+        if(words == null || words.length == 0) return result;
+        int height = board.length, width = board[0].length;
+        boolean[][] visited = new boolean[height][width];
+        Set<String> set = new HashSet<>();
+        for(String word: words){
+            for(int i = 0; i < height; i++){
+                for(int j = 0; j < width; j++){
+                    if(board[i][j] == word.charAt(0)){
+                        visited[i][j] = true;
+                        dfs(board, set, word, i, j, 0, new boolean[height][width]);
+                        visited[i][j] = false;
+                    }
+                }
+            }
+        }
+        result.addAll(set);
+        return result;
+    }
+    int[][] dir = new int[][]{{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
+    private void dfs(char[][] board, Set<String> result, String word, int i, int j, int index, boolean[][] visited){
+        if(index == word.length() - 1){
+            result.add(word);
+        }else{
+            visited[i][j] = true;
+            int tempRow = 0, tempCol = 0;
+            for(int d = 0; d < 4; d++){
+                tempRow = i + dir[d][0];
+                tempCol = j + dir[d][1];
+                if(tempRow >= 0 && tempRow < visited.length && tempCol >= 0 && tempCol < visited[0].length && !visited[tempRow][tempCol] && board[tempRow][tempCol] == word.charAt(index + 1))
+                    dfs(board, result, word, tempRow, tempCol, index + 1, visited);
+            }
+            visited[i][j] = false;
+        }
+    }
+}
+```

leetcode/46. Permutations.md

@@ -72,4 +72,29 @@ class Solution {
         }
     }
 }
-```
+```
+
+### Third time
+```Java
+class Solution {
+    public List<List<Integer>> permute(int[] nums) {
+        List<List<Integer>> result = new LinkedList<>();
+        if(nums.length == 0) return result;
+        dfs(result, nums, new boolean[nums.length], new LinkedList<>());
+        return result;
+    }
+    private void dfs(List<List<Integer>> result, int[] nums, boolean[] visited, List<Integer> temp){
+        if(temp.size() == nums.length) result.add(new LinkedList<Integer>(temp));
+        else{
+            for(int i = 0; i < nums.length; i++){
+                if(visited[i]) continue;
+                visited[i] = true;
+                temp.add(nums[i]);
+                dfs(result, nums, visited, temp);
+                temp.remove(temp.size() - 1);
+                visited[i] = false;
+            }
+        }
+    }
+}
+```

leetcode/52. N-Queens II.md

@@ -105,4 +105,45 @@ class Solution {
         return true;
     }
 }
-```
+```
+
+### Third time
+* Method 1: search + dfs
+  * the global variable is not required, we alse can implement that using return int.
+  ```Java
+  class Solution {
+      public int totalNQueens(int n) {
+          char[][] table = new char[n][n];
+          for(int i = 0; i < n; i++)
+              for(int j = 0; j < n; j++)
+                  table[i][j] = '.';
+          return dfs(table, 0, n);
+      }
+      private int dfs(char[][] table, int row, int n){
+          if(row == n){return 1;}
+          else{
+              int res = 0;
+              for(int i = 0; i < n; i++){
+                  if(check(table, row, i, n)){
+                      table[row][i] = 'Q';
+                      res += dfs(table, row + 1, n);
+                      table[row][i] = '.';
+                  }
+              }
+              return res;
+          }
+      }
+      private boolean check(char[][] table, int row, int col, int n){
+          for(int i = 0; i < n; i++){
+              if(table[row][i] == 'Q') return false;
+              if(table[i][col] == 'Q') return false;
+          }
+          int r = row, c = col;
+          while(row >= 0 && col >= 0)
+              if(table[row--][col--] == 'Q') return false;
+          while(r >= 0 && c < n)
+              if(table[r--][c++] == 'Q') return false;
+          return true;
+      }
+  }
+  ```

leetcode/648. Replace Words.md

@@ -88,3 +88,4 @@ class Solution {
         }
     }
 }
+```

leetcode/676. Implement Magic Dictionary.md

@@ -162,8 +162,7 @@ class Solution {
             }
         }
         return false;
-    }
-    private static int[][] dir = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+    }    
     private boolean exist(char[][] board, char[] word, int index, int row, int col, boolean[][] used){
         if(index == word.length) return true;
         else{
@@ -184,3 +183,35 @@ class Solution {
     }
 }
 ```
+
+### Third time
+* Method 1: Search + dfs
+  ```Java
+  class Solution {
+      public boolean exist(char[][] board, String word) {
+          if(word == null || word.length() == 0) return true;
+          int height = board.length, width = board[0].length;
+          for(int i = 0; i < height; i++){
+              for(int j = 0; j < width; j++){
+                  if(board[i][j] == word.charAt(0))
+                      if(dfs(board, word, i, j, 0, new boolean[height][width])) return true;
+              }
+          }
+          return false;
+      }      
+      private boolean dfs(char[][] board, String word, int i, int j, int index, boolean[][] visited){
+          if(index == word.length() - 1)  return true;
+          visited[i][j] = true;
+          int tempRow = 0, tempCol = 0;
+          for(int d = 0; d < 4; d++){
+              tempRow = i + dir[d][0];
+              tempCol = j + dir[d][1];
+              if(tempRow >= 0 && tempRow < visited.length && tempCol >= 0 && tempCol < visited[0].length && board[tempRow][tempCol] == word.charAt(index + 1) &&  !visited[tempRow][tempCol]){
+                  if(dfs(board, word, tempRow, tempCol, index + 1, visited)) return true;
+              }
+          }
+          visited[i][j] = false;
+          return false;
+      }
+  }
+  ```

leetcode/677. Map Sum Pairs.md

@@ -35,4 +35,57 @@ Note:
 			return (int)(sum % (Math.pow(10, 9) + 7));
 		}
 	}
-	```
+	```
+
+
+* Method 2: Monotic stack
+  1. How many times a number will appear in the results(Not thinking about minimum)
+    * for a element A[i], it will represents (i + 1) * (len - i + 1) times.
+    * i + 1 means the subarrays whose end point is A[i]
+    * (len - i + 1) means the subarrays whose start point is A[i].
+  2. How to solve this question:
+    * res = sum(A[i] * f[i], A[i] is the number and f[i] means the number of subarrays where A[i] is the minimum in the subarray.
+    * f[i] = left[i] * right[i], where left[i] is the left subarray numbers where A[i] is the last element and A[i] is minimum in current array and right[i] is the minimum and first element in the subarray.
+    * How to get left[i] and right[i]. Consider leetcode question 901.
+    * We need to consider a corner case, two elements have the same value.
+
+```Java
+class Solution {
+    private static class Pair{
+        int val;
+        int count;
+        public Pair(int val, int count){
+            this.val = val;
+            this.count = count;
+        }
+    }
+    public int sumSubarrayMins(int[] A) {
+        if(A == null || A.length == 0) return 0;
+        Stack<Pair> left = new Stack<>();
+        int[] leftArr = new int[A.length];
+        Stack<Pair> right = new Stack<>();
+        int[] rightArr = new int[A.length];
+        for(int i = 0; i < A.length; i++){
+            int count = 1;
+            while(!left.isEmpty() && A[i] < left.peek().val){
+                count += left.pop().count;
+            }
+            left.push(new Pair(A[i], count));
+            leftArr[i] = count;
+        }
+        for(int i = A.length - 1; i >= 0; i--){
+            int count = 1;
+            while(!right.isEmpty() && A[i] <= right.peek().val){
+                count += right.pop().count;
+            }
+            right.push(new Pair(A[i], count));
+            rightArr[i] = count;
+        }
+        long res = 0;
+        for(int i = 0; i < A.length; i++){
+            res += A[i] * leftArr[i] * rightArr[i];
+        }
+        return (int)(res % (1e9 + 7));
+    }
+}
+```

leetcode/720. Longest Word in Dictionary.md

@@ -1,7 +1,8 @@
 ## 943. Find the Shortest Superstring
 
-### Question:
+### Question
 Given an array A of strings, find any smallest string that contains each string in A as a substring.
+
 We may assume that no string in A is substring of another string in A.
 
 ```