✨feat: add 1092、1253、1260、1408、1473、1640、1743、1759、1802、236、481、543、6…

LeetCode/1091-1100/1092. 最短公共超序列（困难）.md

@@ -90,36 +90,39 @@ class Solution {
     }
 }
 ```
-TypeScript 代码：
-```TypeScript
-function shortestCommonSupersequence(s1: string, s2: string): string {
-    const n = s1.length, m = s2.length
-    s1 = " " + s1; s2 = " " + s2
-    const f = new Array<Array<number>>()
-    for (let i = 0; i < n + 10; i++) f.push(new Array<number>(m + 10).fill(0))
-    for (let i = 1; i <= n; i++) {
-        for (let j = 1; j <= m; j++) {
-            if (s1[i] == s2[j]) f[i][j] = f[i - 1][j - 1] + 1
-            else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1])
+C++ 代码：
+```C++
+class Solution {
+public:
+    string shortestCommonSupersequence(string str1, string str2) {
+        int n = str1.size(), m = str2.size();
+        str1 = " " + str1; str2 = " " + str2;
+        vector<vector<int>> f(n + 10, vector<int>(m + 10));
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= m; ++j) {
+                if (str1[i] == str2[j])
+                    f[i][j] = f[i - 1][j - 1] + 1;
+                else 
+                    f[i][j] = max(f[i - 1][j], f[i][j - 1]);
+            }
         }
-    }
-    let ans = ""
-    let i = n, j = m
-    while (i > 0 || j > 0) {
-        if (i == 0) ans += s2[j--]
-        else if (j == 0) ans += s1[i--]
-        else {
-            if (s1[i] == s2[j]) {
-                ans += s1[i]
-                i--; j--
-            } else if (f[i][j] == f[i - 1][j]) {
-                ans += s1[i--]
-            } else {
-                ans += s2[j--]
+        string res;
+        int i = n, j = m;
+        while (i > 0 || j > 0) {
+            if (i == 0) res += str2[j--];
+            else if (j == 0) res += str1[i--];
+            else {
+                if (str1[i] == str2[j]) {
+                    res += str1[i];
+                    i--; j--;
+                }
+                else if (f[i][j] == f[i - 1][j]) res += str1[i--];
+                else res += str2[j--];
             }
         }
+        reverse(res.begin(), res.end());
+        return res;
     }
-    return ans.split('').reverse().join('')
 };
 ```
 Python 代码：
@@ -155,6 +158,38 @@ class Solution:
                     j -= 1
         return ans[::-1]
 ```
+TypeScript 代码：
+```TypeScript
+function shortestCommonSupersequence(s1: string, s2: string): string {
+    const n = s1.length, m = s2.length
+    s1 = " " + s1; s2 = " " + s2
+    const f = new Array<Array<number>>()
+    for (let i = 0; i < n + 10; i++) f.push(new Array<number>(m + 10).fill(0))
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            if (s1[i] == s2[j]) f[i][j] = f[i - 1][j - 1] + 1
+            else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1])
+        }
+    }
+    let ans = ""
+    let i = n, j = m
+    while (i > 0 || j > 0) {
+        if (i == 0) ans += s2[j--]
+        else if (j == 0) ans += s1[i--]
+        else {
+            if (s1[i] == s2[j]) {
+                ans += s1[i]
+                i--; j--
+            } else if (f[i][j] == f[i - 1][j]) {
+                ans += s1[i--]
+            } else {
+                ans += s2[j--]
+            }
+        }
+    }
+    return ans.split('').reverse().join('')
+};
+```
 * 时间复杂度：`LCS` 复杂度为 $O(n \times m)$；构造答案复杂度为 $O(n \times m)$。整体复杂度为 $O(n \times m)$
 * 空间复杂度：$O(n \times m)$
 

LeetCode/1251-1260/1253. 重构 2 行二进制矩阵（中等）.md

@@ -61,10 +61,11 @@ Tag : 「模拟」、「贪心」、「构造」
 
 若处理完 `colsum` 后，两行剩余 $1$ 个数恰好均为 $0$，说明构造出了合法方案。
 
-容易证明：**不存在某个决策回合中，必须先填入剩余个数少的一方，才能顺利构造。**可用反证法进行证明，若存在某个回合必须填入剩余个数少的一方（假设该回合上填 `1` 下填 `0`），必然能够找到同为 $colsum[j] = 1$ 的回合进行交换，同时不影响合法性（上下行的总和不变，同时 $colsum[i] = colsum[j] = 1$）。
+容易证明：**不存在某个决策回合中，必须先填入剩余个数少的一方，才能顺利构造。**
 
-代码：
+可用反证法进行证明，若存在某个回合必须填入剩余个数少的一方（假设该回合上填 `1` 下填 `0`），必然能够找到同为 $colsum[j] = 1$ 的回合进行交换，同时不影响合法性（上下行的总和不变，同时 $colsum[i] = colsum[j] = 1$）。
 
+Java 代码：
 ```Java
 class Solution {
     public List<List<Integer>> reconstructMatrix(int upper, int lower, int[] colsum) {
@@ -95,6 +96,93 @@ class Solution {
     }
 }
 ```
+C++ 代码：
+```C++
+class Solution {
+public:
+    vector<vector<int>> reconstructMatrix(int upper, int lower, vector<int>& colsum) {
+        int n = colsum.size();
+        vector<vector<int>> ans;
+        vector<int> a, b;
+        for (int i = 0; i < n; i++) {
+            int m = colsum[i];
+            if (m == 0) {
+                a.push_back(0); b.push_back(0);
+            } else if (m == 2) {
+                upper--; lower--;
+                a.push_back(1); b.push_back(1);
+            } else {
+                if (upper >= lower) {
+                    upper--;
+                    a.push_back(1); b.push_back(0);
+                } else {
+                    lower--;
+                    a.push_back(0); b.push_back(1);
+                }
+            }
+        }
+        if (upper == 0 && lower == 0) {
+            ans.push_back(a); ans.push_back(b);
+        }
+        return ans;
+    }
+};
+```
+Python 代码：
+```Python
+class Solution:
+    def reconstructMatrix(self, upper: int, lower: int, colsum: List[int]) -> List[List[int]]:
+        n = len(colsum)
+        ans = []
+        a, b = [], []
+        for i in range(n):
+            m = colsum[i]
+            if m == 0:
+                a.append(0)
+                b.append(0)
+            elif m == 2:
+                upper, lower = upper - 1, lower - 1
+                a.append(1)
+                b.append(1)
+            else:
+                a.append(1 if upper >= lower else 0)
+                b.append(0 if upper >= lower else 1)
+                if upper >= lower: upper -= 1
+                else: lower -= 1
+        if upper == lower == 0:
+            ans.append(a)
+            ans.append(b)
+        return ans
+```
+TypeScript 代码：
+```TypeScript
+function reconstructMatrix(upper: number, lower: number, colsum: number[]): number[][] {
+    const n = colsum.length;
+    let ans: number[][] = [];
+    let a: number[] = [], b: number[] = [];
+    for (let i = 0; i < n; i++) {
+        const m = colsum[i];
+        if (m === 0) {
+            a.push(0); b.push(0);
+        } else if (m === 2) {
+            upper--; lower--;
+            a.push(1); b.push(1);
+        } else {
+            if (upper >= lower) {
+                upper--;
+                a.push(1); b.push(0);
+            } else {
+                lower--;
+                a.push(0); b.push(1);
+            }
+        }
+    }
+    if (upper === 0 && lower === 0) {
+        ans.push(a); ans.push(b);
+    }
+    return ans;
+};
+```
 * 时间复杂度：$O(C \times n)$，其中 $C = 2$  代表行数
 * 空间复杂度：$O(C \times n)$
 

LeetCode/1251-1260/1260. 二维网格迁移（简单）.md

@@ -6,7 +6,9 @@ Tag : 「模拟」、「构造」
 
 
 
-给你一个 `m` 行 `n` 列的二维网格 `grid` 和一个整数 `k`。你需要将 `grid` 迁移 `k` 次。
+给你一个 `m` 行 `n` 列的二维网格 `grid` 和一个整数 `k`。
+
+你需要将 `grid` 迁移 `k` 次。
 
 每次「迁移」操作将会引发下述活动：
 
@@ -75,6 +77,39 @@ class Solution {
     }
 }
 ```
+C++ 代码：
+```C++
+class Solution {
+public:
+    vector<vector<int>> shiftGrid(vector<vector<int>>& g, int k) {
+        int n = g.size(), m = g[0].size();
+        vector<vector<int>> mat(n, vector<int>(m));
+        for(int i = 0; i < m; ++i) {
+            int tcol = (i + k) % m, trow = ((i + k) / m) % n, idx = 0;
+            while(idx != n) {
+                mat[trow++][tcol] = g[idx++][i];
+                if(trow == n) trow = 0;
+            }
+        }
+        return mat;
+    }
+};
+```
+Python 代码：
+```Python
+class Solution:
+    def shiftGrid(self, g: List[List[int]], k: int) -> List[List[int]]:
+        n, m = len(g), len(g[0])
+        mat = [[0]*m for _ in range(n)]
+        for i in range(m):
+            tcol = (i + k) % m
+            trow = ((i + k) // m) % n
+            idx = 0
+            while idx != n:
+                mat[trow][tcol] = g[idx][i]
+                trow, idx = (trow + 1) % n, idx + 1
+        return mat
+```
 TypeScript 代码：
 ```TypeScript
 function shiftGrid(g: number[][], k: number): number[][] {

LeetCode/1401-1410/1408. 数组中的字符串匹配（简单）.md

@@ -6,7 +6,9 @@ Tag : 「模拟」
 
 
 
-给你一个字符串数组 `words`，数组中的每个字符串都可以看作是一个单词。请你按 任意 顺序返回 `words` 中是其他单词的子字符串的所有单词。
+给你一个字符串数组 `words`，数组中的每个字符串都可以看作是一个单词。
+
+请你按任意顺序返回 `words` 中是其他单词的子字符串的所有单词。
 
 如果你可以删除 `words[j]` 最左侧和/或最右侧的若干字符得到 `word[i]`，那么字符串 `words[i]` 就是 `words[j]` 的一个子字符串。
 

LeetCode/1471-1480/1473. 粉刷房子 III（困难）.md

@@ -83,16 +83,20 @@ Tag : 「动态规划」、「序列 DP」
     同时根据「第 $i$ 间房子的颜色 $j$」与「第 $i - 1$ 间房子的颜色 $p$」是否相同，会决定第 $i$ 间房子是否形成一个新的分区。这同样需要进行分情况讨论。
     整理后的转移方程为：
 
-    $$ f[i][j][k]=\begin{cases}
+    $$
+    f[i][j][k]=\begin{cases}
     min(f[i - 1][j][k], f[i - 1][p][k - 1]) &j == houses[i], p != j\\
     INF & j != houses[i]
-    \end{cases}$$
+    \end{cases}
+    $$
 
 * 第 $i$ 间房子尚未被上色，即 $houses[i] == 0$，此时房子可以被粉刷成任意颜色。不会有无效状态的情况。
   同样，根据「第 $i$ 间房子的颜色 $j$」与「第 $i - 1$ 间房子的颜色 $p$」是否相同，会决定第 $i$ 间房子是否形成一个新的分区。
     转移方程为：
 
-  $$ f[i][j][k] = min(f[i - 1][j][k], f[i - 1][p][k - 1]) + cost[i][j - 1], p != j $$
+  $$
+  f[i][j][k] = min(f[i - 1][j][k], f[i - 1][p][k - 1]) + cost[i][j - 1], p != j
+  $$
 
 一些编码细节：
 
@@ -167,8 +171,8 @@ class Solution {
     }
 }
 ```
-* 时间复杂度：共有 $m * n * t$ 个状态需要被转移，每次转移需要枚举「所依赖的状态」的颜色，复杂度为 $O(n)$。整体复杂度为 $O(m * n^2 * t)$
-* 空间复杂度：$O(m * n * t)$
+* 时间复杂度：共有 $m \times n \times t$ 个状态需要被转移，每次转移需要枚举「所依赖的状态」的颜色，复杂度为 $O(n)$。整体复杂度为 $O(m \times n^2 \times t)$
+* 空间复杂度：$O(m \times n \times t)$
 
 ---
 
@@ -280,8 +284,8 @@ class Solution {
     }
 }
 ```
-* 时间复杂度：共有 $m * n * t$ 个状态需要被转移，每次转移需要枚举「所依赖的状态」的颜色，复杂度为 $O(n)$。整体复杂度为 $O(m * n^2 * t)$
-* 空间复杂度：$O(m * n * t)$
+* 时间复杂度：共有 $m \times n \times t$ 个状态需要被转移，每次转移需要枚举「所依赖的状态」的颜色，复杂度为 $O(n)$。整体复杂度为 $O(m \times n^2 \times t)$
+* 空间复杂度：$O(m \times n \times t)$
 
 ---