feat: add solutions for lc No.1728

Author: yanglbme

solution/1700-1799/1727.Largest Submatrix With Rearrangements/README.md

@@ -84,13 +84,13 @@ tags:
 
 由于题目中矩阵是按列进行重排，因此，我们可以先对矩阵的每一列进行预处理。
 
-对于每个值为 $1$ 的元素，我们更新其值为该元素向上的最大连续的 $1$ 的个数，即 $matrix[i][j]=matrix[i-1][j]+1$。
+对于每个值为 $1$ 的元素，我们更新其值为该元素向上的最大连续的 $1$ 的个数，即 $\text{matrix}[i][j]=\text{matrix}[i-1][j]+1$。
 
 接下来，我们可以对更新后的矩阵的每一行进行排序。然后遍历每一行，计算以该行作为底边的最大全 $1$ 子矩阵的面积。具体计算逻辑如下：
 
-对于矩阵的某一行，我们记第 $k$ 大元素的值为 $val_k$，其中 $k \geq 1$，那么该行至少有 $k$ 个元素不小于 $val_k$，组成的全 $1$ 子矩阵面积为 $val_k \times k$。从大到小遍历矩阵该行的每个元素，取 $val_k \times k$ 的最大值，更新答案。
+对于矩阵的某一行，我们记第 $k$ 大元素的值为 $\text{val}_k$，其中 $k \geq 1$，那么该行至少有 $k$ 个元素不小于 $\text{val}_k$，组成的全 $1$ 子矩阵面积为 $\text{val}_k \times k$。从大到小遍历矩阵该行的每个元素，取 $\text{val}_k \times k$ 的最大值，更新答案。
 
-时间复杂度 $O(m \times n \times \log n)$。其中 $m$ 和 $n$ 分别为矩阵的行数和列数。
+时间复杂度 $O(m \times n \times \log n)$，空间复杂度 $O(\log n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
 
 <!-- tabs:start -->
 

solution/1700-1799/1727.Largest Submatrix With Rearrangements/README_EN.md

@@ -70,15 +70,15 @@ The largest submatrix of 1s, in bold, has an area of 3.
 
 ### Solution 1: Preprocessing + Sorting
 
-Since the matrix is rearranged by columns according to the problem, we can first preprocess each column of the matrix.
+Since the matrix can be rearranged by columns, we can preprocess each column of the matrix first.
 
-For each element with a value of $1$, we update its value to the maximum consecutive number of $1$s above it, that is, $matrix[i][j] = matrix[i-1][j] + 1$.
+For each element with value $1$, we update its value to the maximum number of consecutive $1$s above it (including itself), i.e., $\text{matrix}[i][j] = \text{matrix}[i-1][j] + 1$.
 
-Next, we can sort each row of the updated matrix. Then traverse each row, calculate the area of the largest sub-matrix full of $1$s with this row as the bottom edge. The specific calculation logic is as follows:
+Next, we sort each row of the updated matrix. Then we traverse each row and compute the maximum area of an all-$1$ submatrix with that row as the bottom edge. The detailed calculation is as follows:
 
-For a row of the matrix, we denote the value of the $k$-th largest element as $val_k$, where $k \geq 1$, then there are at least $k$ elements in this row that are not less than $val_k$, forming a sub-matrix full of $1$s with an area of $val_k \times k$. Traverse each element of this row from large to small, take the maximum value of $val_k \times k$, and update the answer.
+For a given row, let the $k$-th largest element be $\text{val}_k$, where $k \geq 1$. Then there are at least $k$ elements in that row no less than $\text{val}_k$, forming an all-$1$ submatrix with area $\text{val}_k \times k$. We iterate through the elements of the row from largest to smallest, take the maximum value of $\text{val}_k \times k$, and update the answer.
 
-The time complexity is $O(m \times n \times \log n)$. Here, $m$ and $n$ are the number of rows and columns of the matrix, respectively.
+The time complexity is $O(m \times n \times \log n)$ and the space complexity is $O(\log n)$, where $m$ and $n$ are the number of rows and columns of the matrix, respectively.
 
 <!-- tabs:start -->
 

solution/1700-1799/1728.Cat and Mouse II/README.md

@@ -143,7 +143,7 @@ tags:
 
 当所有状态的结果都更新完毕时，初始状态的结果即为最终结果。
 
-时间复杂度 $O(m^2 \times n^2 \times (m + n)$，空间复杂度 $O(m^2 \times n^2)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
+时间复杂度 $O(m^2 \times n^2 \times (m + n))$，空间复杂度 $O(m^2 \times n^2)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
 
 <!-- tabs:start -->
 
@@ -600,6 +600,283 @@ func getPrevStates(gMouse, gCat [][]int, m, c, t int, ans [][][]int) [][]int {
 }
 ```
 
+#### TypeScript
+
+```ts
+function canMouseWin(grid: string[], catJump: number, mouseJump: number): boolean {
+    const m = grid.length
+    const n = grid[0].length
+
+    let catStart = 0
+    let mouseStart = 0
+    let food = 0
+
+    const dirs = [-1, 0, 1, 0, -1]
+
+    const gMouse: number[][] = Array.from({ length: m * n }, () => [])
+    const gCat: number[][] = Array.from({ length: m * n }, () => [])
+
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            const c = grid[i][j]
+
+            if (c === '#') continue
+
+            const v = i * n + j
+
+            if (c === 'C') catStart = v
+            else if (c === 'M') mouseStart = v
+            else if (c === 'F') food = v
+
+            for (let d = 0; d < 4; d++) {
+                const a = dirs[d]
+                const b = dirs[d + 1]
+
+                for (let k = 0; k <= mouseJump; k++) {
+                    const x = i + k * a
+                    const y = j + k * b
+
+                    if (!(0 <= x && x < m && 0 <= y && y < n && grid[x][y] !== '#')) break
+
+                    gMouse[v].push(x * n + y)
+                }
+
+                for (let k = 0; k <= catJump; k++) {
+                    const x = i + k * a
+                    const y = j + k * b
+
+                    if (!(0 <= x && x < m && 0 <= y && y < n && grid[x][y] !== '#')) break
+
+                    gCat[v].push(x * n + y)
+                }
+            }
+        }
+    }
+
+    function getPrevStates(m: number, c: number, t: number, ans: number[][][]): number[][] {
+        const pt = t ^ 1
+        const pre: number[][] = []
+
+        if (pt === 1) {
+            for (const pc of gCat[c]) {
+                if (ans[m][pc][1] === 0) pre.push([m, pc, pt])
+            }
+        } else {
+            for (const pm of gMouse[m]) {
+                if (ans[pm][c][0] === 0) pre.push([pm, c, pt])
+            }
+        }
+
+        return pre
+    }
+
+    function calc(): number {
+        const N = m * n
+
+        const degree: number[][][] = Array.from({ length: N }, () =>
+            Array.from({ length: N }, () => [0, 0])
+        )
+
+        const ans: number[][][] = Array.from({ length: N }, () =>
+            Array.from({ length: N }, () => [0, 0])
+        )
+
+        for (let i = 0; i < N; i++) {
+            for (let j = 0; j < N; j++) {
+                degree[i][j][0] = gMouse[i].length
+                degree[i][j][1] = gCat[j].length
+            }
+        }
+
+        const q: number[][] = []
+
+        for (let i = 0; i < N; i++) {
+            ans[food][i][1] = 1
+            ans[i][food][0] = 2
+            ans[i][i][1] = 2
+            ans[i][i][0] = 2
+
+            q.push([food, i, 1])
+            q.push([i, food, 0])
+            q.push([i, i, 0])
+            q.push([i, i, 1])
+        }
+
+        while (q.length) {
+            const [mPos, cPos, t] = q.shift()!
+            const currentAns = ans[mPos][cPos][t]
+
+            for (const [pm, pc, pt] of getPrevStates(mPos, cPos, t, ans)) {
+                if (pt === currentAns - 1) {
+                    ans[pm][pc][pt] = currentAns
+                    q.push([pm, pc, pt])
+                } else {
+                    degree[pm][pc][pt]--
+                    if (degree[pm][pc][pt] === 0) {
+                        ans[pm][pc][pt] = currentAns
+                        q.push([pm, pc, pt])
+                    }
+                }
+            }
+        }
+
+        return ans[mouseStart][catStart][0]
+    }
+
+    return calc() === 1
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn can_mouse_win(grid: Vec<String>, cat_jump: i32, mouse_jump: i32) -> bool {
+        let m = grid.len();
+        let n = grid[0].len();
+
+        let grid: Vec<Vec<char>> = grid.iter().map(|s| s.chars().collect()).collect();
+
+        let mut cat_start = 0usize;
+        let mut mouse_start = 0usize;
+        let mut food = 0usize;
+
+        let dirs = [-1, 0, 1, 0, -1];
+
+        let mut g_mouse = vec![Vec::<usize>::new(); m * n];
+        let mut g_cat = vec![Vec::<usize>::new(); m * n];
+
+        for i in 0..m {
+            for j in 0..n {
+                let c = grid[i][j];
+                if c == '#' {
+                    continue;
+                }
+
+                let v = i * n + j;
+
+                if c == 'C' {
+                    cat_start = v;
+                } else if c == 'M' {
+                    mouse_start = v;
+                } else if c == 'F' {
+                    food = v;
+                }
+
+                for d in 0..4 {
+                    let a = dirs[d];
+                    let b = dirs[d + 1];
+
+                    for k in 0..=mouse_jump {
+                        let x = i as i32 + k * a;
+                        let y = j as i32 + k * b;
+
+                        if !(x >= 0
+                            && x < m as i32
+                            && y >= 0
+                            && y < n as i32
+                            && grid[x as usize][y as usize] != '#')
+                        {
+                            break;
+                        }
+
+                        g_mouse[v].push((x as usize) * n + y as usize);
+                    }
+
+                    for k in 0..=cat_jump {
+                        let x = i as i32 + k * a;
+                        let y = j as i32 + k * b;
+
+                        if !(x >= 0
+                            && x < m as i32
+                            && y >= 0
+                            && y < n as i32
+                            && grid[x as usize][y as usize] != '#')
+                        {
+                            break;
+                        }
+
+                        g_cat[v].push((x as usize) * n + y as usize);
+                    }
+                }
+            }
+        }
+
+        use std::collections::VecDeque;
+
+        let n2 = m * n;
+
+        let mut degree = vec![vec![vec![0i32; 2]; n2]; n2];
+        let mut ans = vec![vec![vec![0i32; 2]; n2]; n2];
+
+        for i in 0..n2 {
+            for j in 0..n2 {
+                degree[i][j][0] = g_mouse[i].len() as i32;
+                degree[i][j][1] = g_cat[j].len() as i32;
+            }
+        }
+
+        let mut q = VecDeque::new();
+
+        for i in 0..n2 {
+            ans[food][i][1] = 1;
+            ans[i][food][0] = 2;
+            ans[i][i][1] = 2;
+            ans[i][i][0] = 2;
+
+            q.push_back((food, i, 1));
+            q.push_back((i, food, 0));
+            q.push_back((i, i, 0));
+            q.push_back((i, i, 1));
+        }
+
+        while let Some((m_pos, c_pos, t)) = q.pop_front() {
+            let current_ans = ans[m_pos][c_pos][t];
+
+            let pt = t ^ 1;
+
+            if pt == 1 {
+                for &pc in &g_cat[c_pos] {
+                    if ans[m_pos][pc][1] != 0 {
+                        continue;
+                    }
+
+                    if pt as i32 == current_ans - 1 {
+                        ans[m_pos][pc][1] = current_ans;
+                        q.push_back((m_pos, pc, 1));
+                    } else {
+                        degree[m_pos][pc][1] -= 1;
+                        if degree[m_pos][pc][1] == 0 {
+                            ans[m_pos][pc][1] = current_ans;
+                            q.push_back((m_pos, pc, 1));
+                        }
+                    }
+                }
+            } else {
+                for &pm in &g_mouse[m_pos] {
+                    if ans[pm][c_pos][0] != 0 {
+                        continue;
+                    }
+
+                    if pt as i32 == current_ans - 1 {
+                        ans[pm][c_pos][0] = current_ans;
+                        q.push_back((pm, c_pos, 0));
+                    } else {
+                        degree[pm][c_pos][0] -= 1;
+                        if degree[pm][c_pos][0] == 0 {
+                            ans[pm][c_pos][0] = current_ans;
+                            q.push_back((pm, c_pos, 0));
+                        }
+                    }
+                }
+            }
+        }
+
+        ans[mouse_start][cat_start][0] == 1
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->