[Function add]

1. Add leetcode solutions with tag search.

Author: Seanforfun

leetcode/307. Range Sum Query - Mutable.md

@@ -183,6 +183,117 @@ class NumArray {
         }
     }
 }
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * obj.update(i,val);
+ * int param_2 = obj.sumRange(i,j);
+ */
+```
+
+### Third time
+1. BIT
+```Java
+class NumArray {
+    private int[] nums;
+    private int[] bit;
+
+    private int lowBit(int x){
+        return x & (-x);
+    }
+    public NumArray(int[] nums) {
+        this.nums = new int[nums.length + 1];
+        for(int i = 0; i < nums.length; i++){
+            this.nums[i + 1] = nums[i];
+        }
+        this.bit = new int[nums.length + 1];
+        for(int i = 1; i < this.nums.length; i++){
+            for(int j = i - lowBit(i) + 1; j <= i; j++)
+                this.bit[i] += this.nums[j];
+        }
+    }
+
+    public void update(int i, int val) {
+        int diff = val - nums[i + 1];
+        nums[i + 1] = val;
+        int index = i + 1;
+        while(index < nums.length){
+            bit[index] += diff;
+            index += lowBit(index);
+        }
+    }
+
+    private int sum(int i){
+        int sum = 0;
+        while(i > 0){
+            sum += bit[i];
+            i -= lowBit(i);
+        }
+        return sum;
+    }    
+    public int sumRange(int i, int j) {
+        return sum(j + 1) - sum(i);
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * obj.update(i,val);
+ * int param_2 = obj.sumRange(i,j);
+ */
+```
+
+2. Segment Tree
+```Java
+class NumArray {
+    private int[] nums;
+    private int[] segment;
+    public NumArray(int[] nums) {
+        if(nums == null || nums.length == 0) return;
+        this.nums = nums;
+        this.segment = new int[nums.length << 2 + 1];
+        insert(1, nums.length, 1);
+    }
+    private void insert(int l, int r, int k){
+        if(l == r) segment[k] = nums[l - 1];
+        else{
+            int m = l + ((r - l) >> 1);
+            insert(l, m, k << 1);
+            insert(m + 1, r, k << 1 | 1);
+            segment[k] = segment[k << 1] + segment[k << 1 | 1];
+        }
+    }
+    
+    public void update(int i, int val) {
+        update(i, val - nums[i], 1, nums.length, 1);
+        this.nums[i] = val;
+    }
+    private void update(int i, int diff, int l, int r, int k){
+        if(l == r) segment[k] += diff;
+        else{
+            int m = l + ((r - l) >> 1);
+            if((i + 1) <= m) update(i, diff, l, m, k << 1);
+            if((i + 1) > m) update(i , diff, m + 1, r, k << 1 | 1);
+            segment[k] = segment[k << 1] + segment[k << 1 | 1];
+        }
+    }
+    
+    public int sumRange(int i, int j) {
+        return sumRange(i + 1, j + 1, 1, this.nums.length, 1);
+    }
+    private int sumRange(int L, int R, int l, int r, int k){
+        if(l >= L && r <= R) return segment[k];
+        else{
+            int m = l + ((r - l) >> 1);
+            int sum = 0;
+            if(L <= m) sum += sumRange(L, R, l, m, k << 1);
+            if(R > m) sum += sumRange(L, R, m + 1, r, k << 1 | 1);
+            return sum;
+        }
+    }
+}
+
 /**
  * Your NumArray object will be instantiated and called as such:
  * NumArray obj = new NumArray(nums);

leetcode/77. Combinations.md

@@ -68,24 +68,23 @@ class Solution {
 ```
 
 ### Third time
+* Method 1: Need to use comparison to remove redundant recursions.
 ```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);
+        List<List<Integer>> result = new ArrayList<>();
+        dfs(result, k, n, new ArrayList<Integer>(), 1, 0);
         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){
+    private void dfs(List<List<Integer>> result, int k, int n, List<Integer> temp, int index, int count){
+        if(count == k){
+            result.add(new ArrayList<Integer>(temp));
+        }else if(count < k && count + (n - index + 1) >= k){
             for(int i = index; i <= n; i++){
                 temp.add(i);
-                dfs(result, k - 1, n, temp, i + 1);
-                temp.remove(temp.size() - 1);
+                dfs(result, k, n, temp, i + 1, count + 1);
+                temp.remove(count);
             }
         }
     }
 }
-```

leetcode/784. Letter Case Permutation.md

@@ -0,0 +1,59 @@
+## 784. Letter Case Permutation
+
+### Question:
+Given a string S, we can transform every letter individually to be lowercase or uppercase to create another string.  Return a list of all possible strings we could create.
+
+```
+Examples:
+Input: S = "a1b2"
+Output: ["a1b2", "a1B2", "A1b2", "A1B2"]
+
+Input: S = "3z4"
+Output: ["3z4", "3Z4"]
+
+Input: S = "12345"
+Output: ["12345"]
+```
+
+Note:
+* S will be a string with length between 1 and 12.
+* S will consist only of letters or digits.
+
+### Solution:
+* Method 1: backtrace
+    * Maintain a temp variable to hold state, can use List or StringBuilder.
+    * Add current possible variable to temp.
+    * backtrace
+    * remove current variable from temp and put next possible variable.
+    ```Java
+    class Solution {
+        public List<String> letterCasePermutation(String S) {
+            List<String> result = new ArrayList<>();
+            if(S.length() == 0){
+                result.add("");
+                return result;   
+            }
+            dfs(result, S.toCharArray(), 0, new StringBuilder());
+            return result;
+        }
+        private void dfs(List<String> result, char[] arr, int index, StringBuilder sb){
+            if(index == arr.length){
+                result.add(sb.toString());
+            }else if(index < arr.length){
+                if(arr[index] >= '0' && arr[index] <= '9'){
+                    sb.append(arr[index]);
+                    dfs(result, arr, index + 1, sb);
+                    sb.deleteCharAt(index);
+                }else{
+                    sb.append(Character.toUpperCase(arr[index]));
+                    dfs(result, arr, index + 1, sb);
+                    sb.deleteCharAt(index);
+                    sb.append(Character.toLowerCase(arr[index]));
+                    dfs(result, arr, index + 1, sb);
+                    sb.deleteCharAt(index);
+                }
+            }
+        }
+    }
+    ```
+

leetcode/90. Subsets II.md

@@ -102,4 +102,27 @@ class Solution {
         }
     }
 }
+```
+
+### Third time
+```Java
+class Solution {
+    public List<List<Integer>> subsetsWithDup(int[] nums) {
+        List<List<Integer>> result = new LinkedList<>();
+        if(nums.length == 0) return result;
+        Arrays.sort(nums);
+        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<>(temp));
+        for(int i = index; i < nums.length; i++){
+            while(i > index && i < nums.length && nums[i] == nums[i - 1]) i++;
+            if(i >= nums.length) break;
+            temp.add(nums[i]);
+            dfs(result, nums, temp, i + 1);
+            temp.remove(temp.size() - 1);
+        }
+    }
+}
 ```

leetcode/907. Sum of Subarray Minimums.md

@@ -0,0 +1,38 @@
+## 907. Sum of Subarray Minimums
+
+### Question
+Given an array of integers A, find the sum of min(B), where B ranges over every (contiguous) subarray of A.
+
+Since the answer may be large, return the answer modulo 10^9 + 7.
+
+```
+Example 1:
+
+Input: [3,1,2,4]
+Output: 17
+Explanation: Subarrays are [3], [1], [2], [4], [3,1], [1,2], [2,4], [3,1,2], [1,2,4], [3,1,2,4]. 
+Minimums are 3, 1, 2, 4, 1, 1, 2, 1, 1, 1.  Sum is 17.
+```
+ 
+Note:
+* 1 <= A.length <= 30000
+* 1 <= A[i] <= 30000
+
+### Solution
+* Method 1: Brutal force O(N^2)
+	```Java
+	class Solution {
+		public int sumSubarrayMins(int[] A) {
+			if(A == null || A.length == 0) return 0;
+			long sum = 0;
+			for(int i = 0; i < A.length; i++){
+				int min = A[i];
+				for(int j = i; j < A.length; j++){
+					min = Math.min(A[j], min);
+					sum += min;
+				}
+			}
+			return (int)(sum % (Math.pow(10, 9) + 7));
+		}
+	}
+	```