feat: solve No.576,1074

Author: BaffinLee

1001-1100/1074. Number of Submatrices That Sum to Target.md

@@ -0,0 +1,96 @@
+# 1074. Number of Submatrices That Sum to Target
+
+- Difficulty: Hard.
+- Related Topics: Array, Hash Table, Matrix, Prefix Sum.
+- Similar Questions: Disconnect Path in a Binary Matrix by at Most One Flip.
+
+## Problem
+
+Given a `matrix` and a `target`, return the number of non-empty submatrices that sum to target.
+
+A submatrix `x1, y1, x2, y2` is the set of all cells `matrix[x][y]` with `x1 <= x <= x2` and `y1 <= y <= y2`.
+
+Two submatrices `(x1, y1, x2, y2)` and `(x1', y1', x2', y2')` are different if they have some coordinate that is different: for example, if `x1 != x1'`.
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2020/09/02/mate1.jpg)
+
+```
+Input: matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0
+Output: 4
+Explanation: The four 1x1 submatrices that only contain 0.
+```
+
+Example 2:
+
+```
+Input: matrix = [[1,-1],[-1,1]], target = 0
+Output: 5
+Explanation: The two 1x2 submatrices, plus the two 2x1 submatrices, plus the 2x2 submatrix.
+```
+
+Example 3:
+
+```
+Input: matrix = [[904]], target = 0
+Output: 0
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= matrix.length <= 100`
+	
+- `1 <= matrix[0].length <= 100`
+	
+- `-1000 <= matrix[i] <= 1000`
+	
+- `-10^8 <= target <= 10^8`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {number}
+ */
+var numSubmatrixSumTarget = function(matrix, target) {
+    var m = matrix.length;
+    var n = matrix[0].length;
+    for (var i = 0; i < m; i++) {
+        for (var j = 1; j < n; j++) {
+            matrix[i][j] += matrix[i][j - 1];
+        }
+    }
+    var res = 0;
+    for (var j1 = 0; j1 < n; j1++) {
+        for (var j2 = j1; j2 < n; j2++) {
+            var map = {};
+            var sum = 0;
+            map[0] = 1;
+            for (var i = 0; i < m; i++) {
+                sum += matrix[i][j2] - (matrix[i][j1 - 1] || 0);
+                if (map[sum - target]) res += map[sum - target];
+                map[sum] = (map[sum] || 0) + 1;
+            }
+        }
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+Prefix sum and hash map.
+
+**Complexity:**
+
+* Time complexity : O(n * n * m).
+* Space complexity : O(n * m).

501-600/576. Out of Boundary Paths.md

@@ -0,0 +1,93 @@
+# 576. Out of Boundary Paths
+
+- Difficulty: Medium.
+- Related Topics: Dynamic Programming.
+- Similar Questions: Knight Probability in Chessboard, Execution of All Suffix Instructions Staying in a Grid.
+
+## Problem
+
+There is an `m x n` grid with a ball. The ball is initially at the position `[startRow, startColumn]`. You are allowed to move the ball to one of the four adjacent cells in the grid (possibly out of the grid crossing the grid boundary). You can apply **at most** `maxMove` moves to the ball.
+
+Given the five integers `m`, `n`, `maxMove`, `startRow`, `startColumn`, return the number of paths to move the ball out of the grid boundary. Since the answer can be very large, return it **modulo** `109 + 7`.
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2021/04/28/out_of_boundary_paths_1.png)
+
+```
+Input: m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0
+Output: 6
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2021/04/28/out_of_boundary_paths_2.png)
+
+```
+Input: m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1
+Output: 12
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= m, n <= 50`
+	
+- `0 <= maxMove <= 50`
+	
+- `0 <= startRow < m`
+	
+- `0 <= startColumn < n`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number} maxMove
+ * @param {number} startRow
+ * @param {number} startColumn
+ * @return {number}
+ */
+var findPaths = function(m, n, maxMove, startRow, startColumn) {
+    var matrix = Array(m).fill(0).map(() => Array(n).fill(0));
+    matrix[startRow][startColumn] = 1;
+    var res = 0;
+    var mod = Math.pow(10, 9) + 7;
+    for (var k = 0; k < maxMove; k++) {
+        var newMatrix = Array(m).fill(0).map(() => Array(n).fill(0));
+        for (var i = 0; i < m; i++) {
+            for (var j = 0; j < n; j++) {
+                newMatrix[i][j] = (
+                    (matrix[i - 1] ? matrix[i - 1][j] : 0) +
+                    (matrix[i][j - 1] || 0) +
+                    (matrix[i + 1] ? matrix[i + 1][j] : 0) +
+                    (matrix[i][j + 1] || 0)
+                ) % mod;
+                if (i === 0) res += matrix[i][j];
+                if (i === m - 1) res += matrix[i][j];
+                if (j === 0) res += matrix[i][j];
+                if (j === n - 1) res += matrix[i][j];
+                res %= mod;
+            }
+        }
+        matrix = newMatrix;
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+Dynamic programming.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).