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

Author: Botao Xiao

README.md

@@ -500,7 +500,7 @@
 1. [Tag table from huahua](https://docs.google.com/spreadsheets/d/1SbpY-04Cz8EWw3A_LBUmDEXKUMO31DBjfeMoA0dlfIA/edit#gid=126913158)
 
 ### Advance
-#### [Trie Tree]()
+#### Trie Tree
 * [208. Implement Trie (Prefix Tree)](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/208.%20Implement%20Trie%20(Prefix%20Tree).md)
 * [648. Replace Words](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/648.%20Replace%20Words.md)
 * [676. Implement Magic Dictionary](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/676.%20Implement%20Magic%20Dictionary.md)
@@ -509,6 +509,28 @@
 * [745. Prefix and Suffix Search](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/745.%20Prefix%20and%20Suffix%20Search.md)
 * Conclusion: [Data structure | Trie Tree 字典树](https://seanforfun.github.io/datastructure/2018/11/07/TrieTree.html)
 
+#### BIT / Segment tree
+* [307. Range Sum Query - Mutable](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/307.%20Range%20Sum%20Query%20-%20Mutable.md)
+* Conclusion: [Data structure | Binary Index Tree](https://seanforfun.github.io/datastructure/2018/03/03/BinaryIndexTree.html)
+* Conclusion: [Data structure | Segment Tree](https://seanforfun.github.io/datastructure/2018/03/04/SegmentTree.html)
+
+#### Monotic stack
+* [84. Largest Rectangle in Histogram](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/84.%20Largest%20Rectangle%20in%20Histogram.md)
+* [85. Maximal Rectangle](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/85.%20Maximal%20Rectangle.md)
+* [901. Online Stock Span](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/901.%20Online%20Stock%20Span.md)
+* [907. Sum of Subarray Minimums](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/907.%20Sum%20of%20Subarray%20Minimums.md)
+
+### Search
+#### Combination
+* [17. Letter Combinations of a Phone Number](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/17.%20Letter%20Combinations%20of%20a%20Phone%20Number.md)
+* [39. Combination Sum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/39.%20Combination%20Sum.md)
+* [40. Combination Sum II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/40.%20Combination%20Sum%20II.md)
+* [77. Combinations](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/77.%20Combinations.md)
+* [79. Word Search](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/79.%20Word%20Search.md)
+* [90. Subsets II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/90.%20Subsets%20II.md)
+* [216. Combination Sum III](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/216.%20Combination%20Sum%20III.md)
+* Conclusion: We can speed up the recursion using an index and if we want all elements used once, we need to sort first and in the for loop, we need to remove duplicate values.
+
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.

leetcode/17. Letter Combinations of a Phone Number.md

@@ -22,7 +22,7 @@ class Solution {
         if(null != digits && digits.length() == 0) return result;
         result.add("");
         String[] d = new String[]{"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
-        
+
         int len = digits.length();
         for(int i = 0; i < len; i++){
             List<String> tempResult = new LinkedList<>();
@@ -65,4 +65,29 @@ class Solution {
         }
     }
 }
-```
+```
+
+### Third time
+```Java
+class Solution {
+    public List<String> letterCombinations(String digits) {
+        String[] letters = new String[]{"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+        List<String> res = new LinkedList<>();
+        if(digits == null || digits.length() == 0) return res;
+        dfs(digits, 0, res, letters, new StringBuilder());
+        return res;
+    }
+    private void dfs(String digits, int index, List<String> result, String[] letters, StringBuilder sb){
+        if(index >= digits.length()){
+            result.add(sb.toString());
+            return;
+        }
+        int i = digits.charAt(index) - '0';
+        for(int j = 0; j < letters[i].length(); j++){
+            sb.append(letters[i].charAt(j));
+            dfs(digits, index + 1, result, letters, sb);
+            sb.deleteCharAt(index);
+        }
+    }
+}
+```

leetcode/216. Combination Sum III.md

@@ -62,7 +62,7 @@ class Solution {
         backtrace(k, n, temp, result, 0, 1);
         return result;
     }
-    
+
     private void backtrace(int k, int n, List<Integer> temp, List<List<Integer>> result, int sum, int cur){
         if(temp.size() == k){
             if(sum == n){
@@ -78,4 +78,26 @@ class Solution {
         }
     }
 }
-```
+```
+
+### Third time
+```Java
+class Solution {
+    public List<List<Integer>> combinationSum3(int k, int n) {
+        List<List<Integer>> result = new LinkedList<>();
+        dfs(result, n, k, 0, new LinkedList<Integer>(), 1);
+        return result;
+    }
+    private void dfs(List<List<Integer>> result, int n, int k, int sum, List<Integer> temp, int index){
+        if(sum == n && temp.size() == k) result.add(new LinkedList<Integer>(temp));
+        else if(sum < n && temp.size() < k){
+            for(int i = index; i <= 9; i++){
+                if(i + sum > n) break;
+                temp.add(i);
+                dfs(result, n, k, sum + i, temp, i + 1);
+                temp.remove(temp.size() - 1);
+            }
+        }
+    }
+}
+```

leetcode/39. Combination Sum.md

@@ -85,4 +85,28 @@ class Solution {
         }
     }
 }
-```
+```
+
+### Third time
+```Java
+class Solution {
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> result = new LinkedList<>();
+        if(candidates == null || candidates.length == 0) return result;
+        dfs(result, candidates, 0, target, new LinkedList<>(), 0);
+        return result;
+    }
+    public void dfs(List<List<Integer>> result, int[] candidates, int index, int target, List<Integer> temp, int sum){
+        if(target == sum){
+            result.add(new LinkedList<Integer>(temp));
+        }else if(sum < target){
+            for(int i = index; i < candidates.length; i++){
+                if(sum + candidates[i] > target) continue;
+                temp.add(candidates[i]);
+                dfs(result, candidates, i, target, temp, sum + candidates[i]);
+                temp.remove(temp.size() - 1);
+            }
+        }
+    }
+}
+```

leetcode/40. Combination Sum II.md

@@ -96,4 +96,30 @@ class Solution {
         }
     }
 }
-```
+```
+
+### Third time
+```Java
+class Solution {
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        List<List<Integer>> result = new LinkedList<>();
+        if(candidates == null || candidates.length == 0) return result;
+        Arrays.sort(candidates);
+        dfs(result, candidates, target, 0, new LinkedList<>(), 0);
+        return result;
+    }
+    private void dfs(List<List<Integer>> result, int[] candidates, int target, int sum, List<Integer> temp, int index){
+        if(sum == target) result.add(new LinkedList<Integer>(temp));
+        else if(sum < target){
+            for(int i = index; i < candidates.length; i++){
+                if(sum + candidates[i] > target) continue;
+                while(i < candidates.length && i > index && candidates[i - 1] == candidates[i]) i++;
+                if(i >= candidates.length) break;
+                temp.add(candidates[i]);
+                dfs(result, candidates, target, sum + candidates[i], temp, i + 1);
+                temp.remove(temp.size() - 1);
+            }
+        }
+    }
+}
+```

leetcode/77. Combinations.md

@@ -66,3 +66,26 @@ class Solution {
     }
 }
 ```
+
+### Third time
+```Java
+class Solution {
+    public List<List<Integer>> combine(int n, int k) {
+        List<List<Integer>> result = new LinkedList<>();
+        if(n < 1 || n < k) return result;
+        dfs(result, k, n, new LinkedList<Integer>(), 1);
+        return result;
+    }
+    private void dfs(List<List<Integer>> result, int k, int n, List<Integer> temp, int index){
+        if(k == 0){
+            result.add(new LinkedList<Integer>(temp));
+        }else if(k > 0){
+            for(int i = index; i <= n; i++){
+                temp.add(i);
+                dfs(result, k - 1, n, temp, i + 1);
+                temp.remove(temp.size() - 1);
+            }
+        }
+    }
+}
+```

leetcode/78. Subsets.md

@@ -81,3 +81,24 @@ class Solution {
     }
 }
 ```
+
+### Third time
+* Method 1: dfs
+```Java
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> result = new LinkedList<>();
+        if(nums.length == 0) return result;
+        dfs(result, nums, new LinkedList<Integer>(), 0);
+        return result;
+    }
+    private void dfs(List<List<Integer>> result, int[] nums, List<Integer> temp, int index){
+        result.add(new LinkedList<Integer>(temp));
+        for(int i = index; i < nums.length; i++){
+            temp.add(nums[i]);
+            dfs(result, nums, temp, i + 1);
+            temp.remove(temp.size() - 1);
+        }
+    }
+}
+```

leetcode/901. Online Stock Span.md

@@ -0,0 +1,66 @@
+## 901. Online Stock Span
+
+### Question
+Write a class StockSpanner which collects daily price quotes for some stock, and returns the span of that stock's price for the current day.
+
+The span of the stock's price today is defined as the maximum number of consecutive days (starting from today and going backwards) for which the price of the stock was less than or equal to today's price.
+
+For example, if the price of a stock over the next 7 days were [100, 80, 60, 70, 60, 75, 85], then the stock spans would be [1, 1, 1, 2, 1, 4, 6].
+
+ ```
+Example 1:
+
+Input: ["StockSpanner","next","next","next","next","next","next","next"], [[],[100],[80],[60],[70],[60],[75],[85]]
+Output: [null,1,1,1,2,1,4,6]
+Explanation:
+First, S = StockSpanner() is initialized.  Then:
+S.next(100) is called and returns 1,
+S.next(80) is called and returns 1,
+S.next(60) is called and returns 1,
+S.next(70) is called and returns 2,
+S.next(60) is called and returns 1,
+S.next(75) is called and returns 4,
+S.next(85) is called and returns 6.
+
+Note that (for example) S.next(75) returned 4, because the last 4 prices
+(including today's price of 75) were less than or equal to today's price.
+```
+
+Note:
+* Calls to StockSpanner.next(int price) will have 1 <= price <= 10^5.
+* There will be at most 10000 calls to StockSpanner.next per test case.
+* There will be at most 150000 calls to StockSpanner.next across all test cases.
+* The total time limit for this problem has been reduced by 75% for C++, and 50% for all other languages.
+
+### Solution:
+* Method 1: Monotic stack:
+  * Keep the stack mono decrease
+  * Step 1 100      [100, 1]                            stack is empty and nothing left is small than 100, push [100, 1] to stack.
+  * Step 2 80       [100, 1][80, 1]                     100 > 80, we push[80, 1] to the stack.
+  * Step 3 60       [100, 1][80, 1][60, 1]              same as previous step, we push [60, 1] to the stack.
+  * Step 4 70       [100, 1][80, 1][70, 2]              60 < 70, so we pop it from the stack and add its count to current one
+  * Step 5 60       [100, 1][80, 1][70, 2][60, 1]       still decreasing, push to stack.
+  * Step 6 75       [100, 1][80, 1][75, 4]              75 > 60 and 75 > 70, pop that two elements and add their counts to current one.
+  * Step 7 85       [100, 1][85, 6]                     same as previous step, pop 80 and 75.
+  ```Java
+  class StockSpanner {
+      private Stack<int[]> stack;
+      public StockSpanner() {
+          this.stack = new Stack<>();
+      }
+
+      public int next(int price) {
+          int count = 1;
+          while(!stack.isEmpty() && stack.peek()[0] <= price){
+              count += stack.pop()[1];
+          }
+          stack.push(new int[]{price, count});
+          return count;
+      }
+  }
+  /**
+   * Your StockSpanner object will be instantiated and called as such:
+   * StockSpanner obj = new StockSpanner();
+   * int param_1 = obj.next(price);
+   */
+  ```