feat: No.935,1727

Author: BaffinLee

1701-1800/1727. Largest Submatrix With Rearrangements.md

@@ -0,0 +1,91 @@
+# 1727. Largest Submatrix With Rearrangements
+
+- Difficulty: Medium.
+- Related Topics: Array, Greedy, Sorting, Matrix.
+- Similar Questions: Max Area of Island.
+
+## Problem
+
+You are given a binary matrix `matrix` of size `m x n`, and you are allowed to rearrange the **columns** of the `matrix` in any order.
+
+Return **the area of the largest submatrix within **`matrix`** where **every** element of the submatrix is **`1`** after reordering the columns optimally.**
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2020/12/29/screenshot-2020-12-30-at-40536-pm.png)
+
+```
+Input: matrix = [[0,0,1],[1,1,1],[1,0,1]]
+Output: 4
+Explanation: You can rearrange the columns as shown above.
+The largest submatrix of 1s, in bold, has an area of 4.
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2020/12/29/screenshot-2020-12-30-at-40852-pm.png)
+
+```
+Input: matrix = [[1,0,1,0,1]]
+Output: 3
+Explanation: You can rearrange the columns as shown above.
+The largest submatrix of 1s, in bold, has an area of 3.
+```
+
+Example 3:
+
+```
+Input: matrix = [[1,1,0],[1,0,1]]
+Output: 2
+Explanation: Notice that you must rearrange entire columns, and there is no way to make a submatrix of 1s larger than an area of 2.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `m == matrix.length`
+	
+- `n == matrix[i].length`
+	
+- `1 <= m * n <= 105`
+	
+- `matrix[i][j]` is either `0` or `1`.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} matrix
+ * @return {number}
+ */
+var largestSubmatrix = function(matrix) {
+    var max = 0;
+    for (var i = 0; i < matrix.length; i++) {
+        for (var j = 0; j < matrix[i].length; j++) {
+            if (matrix[i][j] !== 0 && i > 0) {
+                matrix[i][j] = matrix[i - 1][j] + 1;
+            }
+        }
+        var arr = [...matrix[i]].sort((a, b) => b - a);
+        for (var j = 0; j < arr.length; j++) {
+            if (arr[j] === 0) break;
+            max = Math.max(max, arr[j] * (j + 1));
+        }
+    }
+    return max;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

901-1000/935. Knight Dialer.md

@@ -0,0 +1,111 @@
+# 935. Knight Dialer
+
+- Difficulty: Medium.
+- Related Topics: Dynamic Programming.
+- Similar Questions: .
+
+## Problem
+
+The chess knight has a **unique movement**, it may move two squares vertically and one square horizontally, or two squares horizontally and one square vertically (with both forming the shape of an **L**). The possible movements of chess knight are shown in this diagaram:
+
+A chess knight can move as indicated in the chess diagram below:
+
+![](https://assets.leetcode.com/uploads/2020/08/18/chess.jpg)
+
+We have a chess knight and a phone pad as shown below, the knight **can only stand on a numeric cell** (i.e. blue cell).
+
+![](https://assets.leetcode.com/uploads/2020/08/18/phone.jpg)
+
+Given an integer `n`, return how many distinct phone numbers of length `n` we can dial.
+
+You are allowed to place the knight **on any numeric cell** initially and then you should perform `n - 1` jumps to dial a number of length `n`. All jumps should be **valid** knight jumps.
+
+As the answer may be very large, **return the answer modulo** `109 + 7`.
+
+ 
+Example 1:
+
+```
+Input: n = 1
+Output: 10
+Explanation: We need to dial a number of length 1, so placing the knight over any numeric cell of the 10 cells is sufficient.
+```
+
+Example 2:
+
+```
+Input: n = 2
+Output: 20
+Explanation: All the valid number we can dial are [04, 06, 16, 18, 27, 29, 34, 38, 40, 43, 49, 60, 61, 67, 72, 76, 81, 83, 92, 94]
+```
+
+Example 3:
+
+```
+Input: n = 3131
+Output: 136006598
+Explanation: Please take care of the mod.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= n <= 5000`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var knightDialer = function(n) {
+    var res = 0;
+    var mod = Math.pow(10, 9) + 7;
+    var dp = Array(10).fill(0).map(() => Array(n + 1));
+    for (var i = 0; i < 10; i++) {
+        res += helper(n, i, dp);
+        res %= mod;
+    }
+    return res;
+};
+
+var helper = function(n, i, dp) {
+    if (n === 1) return 1;
+    if (i === 5) return 0;
+    if (dp[i][n] !== undefined) return dp[i][n];
+    var mod = Math.pow(10, 9) + 7;
+    var jumpMap = [
+        [4,6],
+        [6,8],
+        [7,9],
+        [4,8],
+        [3,9,0],
+        [],
+        [1,7,0],
+        [2,6],
+        [1,3],
+        [2,4]
+    ];
+    var res = 0;
+    for (var j = 0; j < jumpMap[i].length; j++) {
+        res += helper(n - 1, jumpMap[i][j], dp);
+        res %= mod;
+    }
+    dp[i][n] = res;
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).