[Function add]

1. Add leetcode solutions.

Author: Seanforfun

README.md

@@ -469,6 +469,12 @@
 
 [300. Longest Increasing Subsequence](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/300.%20Longest%20Increasing%20Subsequence.md)
 
+[301. Remove Invalid Parentheses](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/301.%20Remove%20Invalid%20Parentheses.md)
+
+[303. Range Sum Query - Immutable](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/303.%20Range%20Sum%20Query%20-%20Immutable.md)
+
+[304. Range Sum Query 2D - Immutable](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/304.%20Range%20Sum%20Query%202D%20-%20Immutable.md)
+
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.

leetcode/301. Remove Invalid Parentheses.md

@@ -0,0 +1,80 @@
+## 301. Remove Invalid Parentheses
+
+### Question
+Remove the minimum number of invalid parentheses in order to make the input string valid. Return all possible results.
+
+Note: The input string may contain letters other than the parentheses ( and ).
+
+```
+Example 1:
+
+Input: "()())()"
+Output: ["()()()", "(())()"]
+
+Example 2:
+
+Input: "(a)())()"
+Output: ["(a)()()", "(a())()"]
+
+Example 3:
+
+Input: ")("
+Output: [""]
+```
+
+### Thinking:
+* This question can use dfs to solve, and this question can be divided into 2 parts:
+    1. Find the minimun '(' number and ')' number to delete.
+    2. dfs: remove ')' first and then remove '('.
+```Java
+class Solution {
+    public List<String> removeInvalidParentheses(String s) {
+        int l = 0, r = 0;
+        char[] arr = s.toCharArray();
+        for(char c : arr){  // Check the minimum ( and ) to delete.
+            if(c != '(' && c != ')')  continue;
+            if(c == '(') l++;
+            else{
+                if(l <= 0) r++;
+                else l--;
+            }
+        }
+        List<String> result = new LinkedList<>();
+        dfs(s, l, r, 0, result);
+        if(result.size() == 0) result.add("");
+        return result;
+    }
+    private void dfs(String s, int l, int r, int index, List<String> result){
+        if(l == 0 && r == 0 && isValid(s)) result.add(s);   //if no ( or ) to delete and current string is valid, we can add this string to result list.
+        char[] arr = s.toCharArray();
+        for(int i = index; i < s.length(); i++){
+            // if we have continuous ( or ), we just need to remove this first one so we won't get any duplicate result.
+            if((arr[i] != '(' && arr[i] != ')') || (i > 0 && arr[i - 1] == arr[i])) continue;
+            // We first delete ) for pruning
+            if(r > 0 && arr[i] == ')'){
+                // if we remove right, we need to decrease r and renew the current index.
+                dfs(s.substring(0, i) + s.substring(i + 1), l, r - 1, i, result);
+            }else if(l > 0 && arr[i] == '('){
+            // if we remove right, we need to decrease l and renew the current index.
+                dfs(s.substring(0, i) + s.substring(i + 1), l - 1, r, i, result);
+            }
+        }
+    }
+    private boolean isValid(String s){
+        int count = 0;
+        char[] arr = s.toCharArray();
+        for(char c : arr){
+            if(c != '(' && c != ')')  continue;
+            if(c == '(') count++;
+            else{
+                if(count > 0) count--;
+                else return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+### Reference
+1. [花花酱 LeetCode 301. Remove Invalid Parentheses - 刷题找工作 EP139](https://www.youtube.com/watch?v=2k_rS_u6EBk)

leetcode/303. Range Sum Query - Immutable.md

@@ -1,4 +1,23 @@
 ## 303. Range Sum Query - Immutable
+
+### Question:
+Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.
+
+```
+Example:
+
+Given nums = [-2, 0, 3, -5, 2, -1]
+
+sumRange(0, 2) -> 1
+sumRange(2, 5) -> -1
+sumRange(0, 5) -> -3
+```
+
+Note:
+
+1. You may assume that the array does not change.
+2. There are many calls to sumRange function.
+
 ### Thinking:
 * Method 1:
 	* 通过dp，存储从开头加至当前的和。
@@ -17,6 +36,76 @@ class NumArray {
         return sum[j+1] - sum[i];
     }
 }
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * int param_1 = obj.sumRange(i,j);
+ */
+```
+
+### Second time
+1. Use a 2-D array to save sum from i to j. MLE
+```Java
+class NumArray {
+    private int[][]dp;
+    public NumArray(int[] nums) {
+        int len = nums.length;
+        dp = new int[len][len];
+        for(int i = 0; i < len; i++){
+            for(int j = i; j < len; j++){
+                dp[i][j] = nums[j] + (j > 0 ? dp[i][j - 1]: 0);
+            }
+        }
+    }
+    public int sumRange(int i, int j) {
+        return dp[i][j];
+    }
+}
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * int param_1 = obj.sumRange(i,j);
+ */
+```
+
+2. Use for loop to calculate the result every time.
+```Java
+class NumArray {
+    private int[] nums;
+    public NumArray(int[] nums) {
+        this.nums = nums;
+    }    
+    public int sumRange(int i, int j) {
+        int sum = 0;
+        for(int s = i; s <= j; s++){
+            sum += nums[s];
+        }
+        return sum;
+    }
+}
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * int param_1 = obj.sumRange(i,j);
+ */
+```
+
+3. We only need one dimension array to save the sum of the array up to current position, when we need to calculate sumRange(i, j), we can use sum[j] - sum[i - 1] to get the result;
+```Java
+class NumArray {
+    private int[] sum;
+    public NumArray(int[] nums) {
+        this.sum = new int[nums.length];
+        int count = 0;
+        for(int i = 0; i < nums.length; i++){
+            count += nums[i];
+            sum[i] = count;
+        }
+    }
+    public int sumRange(int i, int j) {
+        return sum[j] - (i > 0 ? sum[i - 1] : 0);
+    }
+}
 /**
  * Your NumArray object will be instantiated and called as such:
  * NumArray obj = new NumArray(nums);

leetcode/304. Range Sum Query 2D - Immutable.md

@@ -1,4 +1,31 @@
 ## 304. Range Sum Query 2D - Immutable
+
+### Question:
+Given a 2D matrix matrix, find the sum of the elements inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).
+
+```
+Example:
+
+Given matrix = [
+  [3, 0, 1, 4, 2],
+  [5, 6, 3, 2, 1],
+  [1, 2, 0, 1, 5],
+  [4, 1, 0, 1, 7],
+  [1, 0, 3, 0, 5]
+]
+
+sumRegion(2, 1, 4, 3) -> 8
+sumRegion(1, 1, 2, 2) -> 11
+sumRegion(1, 2, 2, 4) -> 12
+```
+
+Note:
+1. You may assume that the matrix does not change.
+2. There are many calls to sumRegion function.
+3. You may assume that row1 ≤ row2 and col1 ≤ col2.
+
+
+
 ### Thinking:
 * Method 1:
 	* 参考[303. Range Sum Query - Immutable](https://github.com/Seanforfun/Algorithm/blob/master/leetcode/303.%20Range%20Sum%20Query%20-%20Immutable.md)
@@ -68,6 +95,41 @@ class NumMatrix {
         return result;
     }
 }
+/**
+ * Your NumMatrix object will be instantiated and called as such:
+ * NumMatrix obj = new NumMatrix(matrix);
+ * int param_1 = obj.sumRegion(row1,col1,row2,col2);
+ */
+```
+
+### Second time
+1. Use a 2-D array to save the rectangle sum from (0, 0) to current point.
+```Java
+class NumMatrix {
+    private int[][] dp;
+    public NumMatrix(int[][] matrix) {
+        if(matrix == null || matrix.length == 0 || matrix[0].length == 0){
+            dp = new int[0][0];
+            return;
+        }
+        int height = matrix.length, width = matrix[0].length;
+        dp = new int[height][width];
+        for(int i = 0; i < height; i++){
+            for(int j = 0; j < width; j++){
+                int cur = 0;
+                for(int p = 0; p <= i; p++){
+                    cur += matrix[p][j];
+                }
+                dp[i][j] = (j > 0 ? dp[i][j - 1]: 0) + cur;
+            }
+        }
+    }    
+    public int sumRegion(int row1, int col1, int row2, int col2) {
+        return dp[row2][col2] - (col1 > 0 ? dp[row2][col1 - 1]: 0)
+            - (row1 > 0 ? dp[row1 - 1][col2]: 0)
+            + (col1 > 0 && row1 > 0 ? dp[row1 - 1][col1 - 1]: 0);
+    }
+}
 /**
  * Your NumMatrix object will be instantiated and called as such:
  * NumMatrix obj = new NumMatrix(matrix);