feat: solve No.304

Author: BaffinLee

301-400/304. Range Sum Query 2D - Immutable.md

@@ -0,0 +1,110 @@
+# 304. Range Sum Query 2D - Immutable
+
+- Difficulty: Medium.
+- Related Topics: Array, Design, Matrix, Prefix Sum.
+- Similar Questions: Range Sum Query - Immutable, Range Sum Query 2D - Mutable.
+
+## Problem
+
+Given a 2D matrix `matrix`, handle multiple queries of the following type:
+
+
+	
+- Calculate the **sum** of the elements of `matrix` inside the rectangle defined by its **upper left corner** `(row1, col1)` and **lower right corner** `(row2, col2)`.
+
+
+Implement the `NumMatrix` class:
+
+
+	
+- `NumMatrix(int[][] matrix)` Initializes the object with the integer matrix `matrix`.
+	
+- `int sumRegion(int row1, int col1, int row2, int col2)` Returns the **sum** of the elements of `matrix` inside the rectangle defined by its **upper left corner** `(row1, col1)` and **lower right corner** `(row2, col2)`.
+
+
+You must design an algorithm where `sumRegion` works on `O(1)` time complexity.
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2021/03/14/sum-grid.jpg)
+
+```
+Input
+["NumMatrix", "sumRegion", "sumRegion", "sumRegion"]
+[[[[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]]], [2, 1, 4, 3], [1, 1, 2, 2], [1, 2, 2, 4]]
+Output
+[null, 8, 11, 12]
+
+Explanation
+NumMatrix numMatrix = new NumMatrix([[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]]);
+numMatrix.sumRegion(2, 1, 4, 3); // return 8 (i.e sum of the red rectangle)
+numMatrix.sumRegion(1, 1, 2, 2); // return 11 (i.e sum of the green rectangle)
+numMatrix.sumRegion(1, 2, 2, 4); // return 12 (i.e sum of the blue rectangle)
+```
+
+ 
+**Constraints:**
+
+
+	
+- `m == matrix.length`
+	
+- `n == matrix[i].length`
+	
+- `1 <= m, n <= 200`
+	
+- `-104 <= matrix[i][j] <= 104`
+	
+- `0 <= row1 <= row2 < m`
+	
+- `0 <= col1 <= col2 < n`
+	
+- At most `104` calls will be made to `sumRegion`.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} matrix
+ */
+var NumMatrix = function(matrix) {
+    var m = matrix.length;
+    var n = matrix[0].length;
+    var cache = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
+    for (var i = 1; i <= m; i++) {
+        for (var j = 1; j <= n; j++) {
+            cache[i][j] = cache[i - 1][j] + cache[i][j - 1] - cache[i - 1][j - 1] + matrix[i - 1][j - 1];
+        }
+    }
+    this.cache = cache;
+};
+
+/** 
+ * @param {number} row1 
+ * @param {number} col1 
+ * @param {number} row2 
+ * @param {number} col2
+ * @return {number}
+ */
+NumMatrix.prototype.sumRegion = function(row1, col1, row2, col2) {
+    return this.cache[row2 + 1][col2 + 1] - this.cache[row2 + 1][col1] - this.cache[row1][col2 + 1] + this.cache[row1][col1];
+};
+
+/** 
+ * Your NumMatrix object will be instantiated and called as such:
+ * var obj = new NumMatrix(matrix)
+ * var param_1 = obj.sumRegion(row1,col1,row2,col2)
+ */
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(1).
+* Space complexity : O(n).