Merge branch 'doocs:main' into main

Author: Nothing-avil

.github/workflows/pr-add-label.yml

@@ -61,6 +61,7 @@ twitter.getNewsFeed(1);  // 用户 1 获取推文应当返回一个列表，其
 	<li><code>0 &lt;= tweetId &lt;= 10<sup>4</sup></code></li>
 	<li>所有推特的 ID 都互不相同</li>
 	<li><code>postTweet</code>、<code>getNewsFeed</code>、<code>follow</code> 和 <code>unfollow</code> 方法最多调用 <code>3 * 10<sup>4</sup></code> 次</li>
+	<li>用户不能关注自己</li>
 </ul>
 
 <!-- description:end -->

solution/0300-0399/0355.Design Twitter/README.md

@@ -60,6 +60,7 @@ twitter.getNewsFeed(1);  // User 1's news feed should return a list with 1 t
 	<li><code>0 &lt;= tweetId &lt;= 10<sup>4</sup></code></li>
 	<li>All the tweets have <strong>unique</strong> IDs.</li>
 	<li>At most <code>3 * 10<sup>4</sup></code> calls will be made to <code>postTweet</code>, <code>getNewsFeed</code>, <code>follow</code>, and <code>unfollow</code>.</li>
+	<li>A user cannot follow himself.</li>
 </ul>
 
 <!-- description:end -->

solution/0300-0399/0355.Design Twitter/README_EN.md

@@ -65,19 +65,19 @@ tags:
 
 ### 方法一：动态规划
 
-我们定义 $f[h][i][j]$ 表示骑士从 $(i, j)$ 位置出发，走了 $h$ 步以后还留在棋盘上的概率。那么最终答案就是 $f[k][row][column]$。
+我们定义 $f[h][i][j]$ 表示骑士从 $(i, j)$ 位置出发，走了 $h$ 步以后还留在棋盘上的概率。那么最终答案就是 $f[k][\textit{row}][\textit{column}]$。
 
 当 $h=0$ 时，骑士一定在棋盘上，概率为 $1$，即 $f[0][i][j]=1$。
 
 当 $h \gt 0$ 时，骑士在 $(i, j)$ 位置上的概率可以由其上一步的 $8$ 个位置上的概率转移得到，即：
 
 $$
-f[h][i][j] = \sum_{a, b} f[h - 1][a][b] \times \frac{1}{8}
+f[h][i][j] = \sum_{x, y} f[h - 1][x][y] \times \frac{1}{8}
 $$
 
-其中 $(a, b)$ 是从 $(i, j)$ 位置可以走到的 $8$ 个位置中的一个。
+其中 $(x, y)$ 是从 $(i, j)$ 位置可以走到的 $8$ 个位置中的一个。
 
-最终答案即为 $f[k][row][column]$。
+最终答案即为 $f[k][\textit{row}][\textit{column}]$。
 
 时间复杂度 $O(k \times n^2)$，空间复杂度 $O(k \times n^2)$。其中 $k$ 和 $n$ 分别是给定的步数和棋盘大小。
 
@@ -197,9 +197,9 @@ func knightProbability(n int, k int, row int, column int) float64 {
 
 ```ts
 function knightProbability(n: number, k: number, row: number, column: number): number {
-    const f = new Array(k + 1)
-        .fill(0)
-        .map(() => new Array(n).fill(0).map(() => new Array(n).fill(0)));
+    const f = Array.from({ length: k + 1 }, () =>
+        Array.from({ length: n }, () => Array(n).fill(0)),
+    );
     for (let i = 0; i < n; ++i) {
         for (let j = 0; j < n; ++j) {
             f[0][i][j] = 1;
@@ -226,55 +226,39 @@ function knightProbability(n: number, k: number, row: number, column: number): n
 #### Rust
 
 ```rust
-const DIR: [(i32, i32); 8] = [
-    (-2, -1),
-    (2, -1),
-    (-1, -2),
-    (1, -2),
-    (2, 1),
-    (-2, 1),
-    (1, 2),
-    (-1, 2),
-];
-const P: f64 = 1.0 / 8.0;
-
 impl Solution {
-    #[allow(dead_code)]
     pub fn knight_probability(n: i32, k: i32, row: i32, column: i32) -> f64 {
-        // Here dp[i][j][k] represents through `i` steps, the probability that the knight stays on the board
-        // Starts from row: `j`, column: `k`
-        let mut dp: Vec<Vec<Vec<f64>>> =
-            vec![vec![vec![0 as f64; n as usize]; n as usize]; k as usize + 1];
-
-        // Initialize the dp vector, since dp[0][j][k] should be 1
-        for j in 0..n as usize {
-            for k in 0..n as usize {
-                dp[0][j][k] = 1.0;
+        let n = n as usize;
+        let k = k as usize;
+
+        let mut f = vec![vec![vec![0.0; n]; n]; k + 1];
+
+        for i in 0..n {
+            for j in 0..n {
+                f[0][i][j] = 1.0;
             }
         }
 
-        // Begin the actual dp process
-        for i in 1..=k {
-            for j in 0..n {
-                for k in 0..n {
-                    for (dx, dy) in DIR {
-                        let x = j + dx;
-                        let y = k + dy;
-                        if Self::check_bounds(x, y, n, n) {
-                            dp[i as usize][j as usize][k as usize] +=
-                                P * dp[(i as usize) - 1][x as usize][y as usize];
+        let dirs = [-2, -1, 2, 1, -2, 1, 2, -1, -2];
+
+        for h in 1..=k {
+            for i in 0..n {
+                for j in 0..n {
+                    for p in 0..8 {
+                        let x = i as isize + dirs[p];
+                        let y = j as isize + dirs[p + 1];
+
+                        if x >= 0 && x < n as isize && y >= 0 && y < n as isize {
+                            let x = x as usize;
+                            let y = y as usize;
+                            f[h][i][j] += f[h - 1][x][y] / 8.0;
                         }
                     }
                 }
             }
         }
 
-        dp[k as usize][row as usize][column as usize]
-    }
-
-    #[allow(dead_code)]
-    fn check_bounds(i: i32, j: i32, n: i32, m: i32) -> bool {
-        i >= 0 && i < n && j >= 0 && j < m
+        f[k][row as usize][column as usize]
     }
 }
 ```

solution/0600-0699/0688.Knight Probability in Chessboard/README.md

@@ -61,21 +61,21 @@ The total probability the knight stays on the board is 0.0625.
 
 ### Solution 1: Dynamic Programming
 
-Let $f[h][i][j]$ denotes the probability that the knight is still on the chessboard after $h$ steps starting from the position $(i, j)$. Then the final answer is $f[k][row][column]$.
+We define $f[h][i][j]$ to represent the probability that the knight remains on the board after taking $h$ steps starting from position $(i, j)$. The final answer is $f[k][\textit{row}][\textit{column}]$.
 
-When $h = 0$, the knight is always on the chessboard, so $f[0][i][j] = 1$.
+When $h=0$, the knight is definitely on the board, so the probability is $1$, i.e., $f[0][i][j]=1$.
 
-When $h \gt 0$, the probability that the knight is on the position $(i, j)$ can be transferred from the probability on its $8$ adjacent positions, which are:
+When $h \gt 0$, the probability that the knight is at position $(i, j)$ can be derived from the probabilities of the $8$ possible positions it could have come from in the previous step, i.e.,
 
 $$
-f[h][i][j] = \sum_{a, b} f[h - 1][a][b] \times \frac{1}{8}
+f[h][i][j] = \sum_{x, y} f[h - 1][x][y] \times \frac{1}{8}
 $$
 
-where $(a, b)$ is one of the $8$ adjacent positions.
+where $(x, y)$ is one of the $8$ positions the knight can move to from $(i, j)$.
 
-The final answer is $f[k][row][column]$.
+The final answer is $f[k][\textit{row}][\textit{column}]$.
 
-The time complexity is $O(k \times n^2)$, and the space complexity is $O(k \times n^2)$. Here $k$ and $n$ are the given steps and the chessboard size, respectively.
+The time complexity is $O(k \times n^2)$, and the space complexity is $O(k \times n^2)$. Here, $k$ and $n$ are the given number of steps and the size of the board, respectively.
 
 <!-- tabs:start -->
 
@@ -193,9 +193,9 @@ func knightProbability(n int, k int, row int, column int) float64 {
 
 ```ts
 function knightProbability(n: number, k: number, row: number, column: number): number {
-    const f = new Array(k + 1)
-        .fill(0)
-        .map(() => new Array(n).fill(0).map(() => new Array(n).fill(0)));
+    const f = Array.from({ length: k + 1 }, () =>
+        Array.from({ length: n }, () => Array(n).fill(0)),
+    );
     for (let i = 0; i < n; ++i) {
         for (let j = 0; j < n; ++j) {
             f[0][i][j] = 1;
@@ -222,55 +222,39 @@ function knightProbability(n: number, k: number, row: number, column: number): n
 #### Rust
 
 ```rust
-const DIR: [(i32, i32); 8] = [
-    (-2, -1),
-    (2, -1),
-    (-1, -2),
-    (1, -2),
-    (2, 1),
-    (-2, 1),
-    (1, 2),
-    (-1, 2),
-];
-const P: f64 = 1.0 / 8.0;
-
 impl Solution {
-    #[allow(dead_code)]
     pub fn knight_probability(n: i32, k: i32, row: i32, column: i32) -> f64 {
-        // Here dp[i][j][k] represents through `i` steps, the probability that the knight stays on the board
-        // Starts from row: `j`, column: `k`
-        let mut dp: Vec<Vec<Vec<f64>>> =
-            vec![vec![vec![0 as f64; n as usize]; n as usize]; k as usize + 1];
-
-        // Initialize the dp vector, since dp[0][j][k] should be 1
-        for j in 0..n as usize {
-            for k in 0..n as usize {
-                dp[0][j][k] = 1.0;
+        let n = n as usize;
+        let k = k as usize;
+
+        let mut f = vec![vec![vec![0.0; n]; n]; k + 1];
+
+        for i in 0..n {
+            for j in 0..n {
+                f[0][i][j] = 1.0;
             }
         }
 
-        // Begin the actual dp process
-        for i in 1..=k {
-            for j in 0..n {
-                for k in 0..n {
-                    for (dx, dy) in DIR {
-                        let x = j + dx;
-                        let y = k + dy;
-                        if Self::check_bounds(x, y, n, n) {
-                            dp[i as usize][j as usize][k as usize] +=
-                                P * dp[(i as usize) - 1][x as usize][y as usize];
+        let dirs = [-2, -1, 2, 1, -2, 1, 2, -1, -2];
+
+        for h in 1..=k {
+            for i in 0..n {
+                for j in 0..n {
+                    for p in 0..8 {
+                        let x = i as isize + dirs[p];
+                        let y = j as isize + dirs[p + 1];
+
+                        if x >= 0 && x < n as isize && y >= 0 && y < n as isize {
+                            let x = x as usize;
+                            let y = y as usize;
+                            f[h][i][j] += f[h - 1][x][y] / 8.0;
                         }
                     }
                 }
             }
         }
 
-        dp[k as usize][row as usize][column as usize]
-    }
-
-    #[allow(dead_code)]
-    fn check_bounds(i: i32, j: i32, n: i32, m: i32) -> bool {
-        i >= 0 && i < n && j >= 0 && j < m
+        f[k][row as usize][column as usize]
     }
 }
 ```

solution/0600-0699/0688.Knight Probability in Chessboard/README_EN.md

@@ -1,51 +1,35 @@
-const DIR: [(i32, i32); 8] = [
-    (-2, -1),
-    (2, -1),
-    (-1, -2),
-    (1, -2),
-    (2, 1),
-    (-2, 1),
-    (1, 2),
-    (-1, 2),
-];
-const P: f64 = 1.0 / 8.0;
-
 impl Solution {
-    #[allow(dead_code)]
     pub fn knight_probability(n: i32, k: i32, row: i32, column: i32) -> f64 {
-        // Here dp[i][j][k] represents through `i` steps, the probability that the knight stays on the board
-        // Starts from row: `j`, column: `k`
-        let mut dp: Vec<Vec<Vec<f64>>> =
-            vec![vec![vec![0 as f64; n as usize]; n as usize]; k as usize + 1];
+        let n = n as usize;
+        let k = k as usize;
+
+        let mut f = vec![vec![vec![0.0; n]; n]; k + 1];
 
-        // Initialize the dp vector, since dp[0][j][k] should be 1
-        for j in 0..n as usize {
-            for k in 0..n as usize {
-                dp[0][j][k] = 1.0;
+        for i in 0..n {
+            for j in 0..n {
+                f[0][i][j] = 1.0;
             }
         }
 
-        // Begin the actual dp process
-        for i in 1..=k {
-            for j in 0..n {
-                for k in 0..n {
-                    for (dx, dy) in DIR {
-                        let x = j + dx;
-                        let y = k + dy;
-                        if Self::check_bounds(x, y, n, n) {
-                            dp[i as usize][j as usize][k as usize] +=
-                                P * dp[(i as usize) - 1][x as usize][y as usize];
+        let dirs = [-2, -1, 2, 1, -2, 1, 2, -1, -2];
+
+        for h in 1..=k {
+            for i in 0..n {
+                for j in 0..n {
+                    for p in 0..8 {
+                        let x = i as isize + dirs[p];
+                        let y = j as isize + dirs[p + 1];
+
+                        if x >= 0 && x < n as isize && y >= 0 && y < n as isize {
+                            let x = x as usize;
+                            let y = y as usize;
+                            f[h][i][j] += f[h - 1][x][y] / 8.0;
                         }
                     }
                 }
             }
         }
 
-        dp[k as usize][row as usize][column as usize]
-    }
-
-    #[allow(dead_code)]
-    fn check_bounds(i: i32, j: i32, n: i32, m: i32) -> bool {
-        i >= 0 && i < n && j >= 0 && j < m
+        f[k][row as usize][column as usize]
     }
 }

solution/0600-0699/0688.Knight Probability in Chessboard/Solution.rs

@@ -1,7 +1,7 @@
 function knightProbability(n: number, k: number, row: number, column: number): number {
-    const f = new Array(k + 1)
-        .fill(0)
-        .map(() => new Array(n).fill(0).map(() => new Array(n).fill(0)));
+    const f = Array.from({ length: k + 1 }, () =>
+        Array.from({ length: n }, () => Array(n).fill(0)),
+    );
     for (let i = 0; i < n; ++i) {
         for (let j = 0; j < n; ++j) {
             f[0][i][j] = 1;

solution/0600-0699/0688.Knight Probability in Chessboard/Solution.ts

@@ -93,7 +93,7 @@ tags:
 
 若 $n$ 为奇数，那么最终的合法棋盘只有一种可能。如果第一行中 $0$ 的数目大于 $1$，那么最终一盘的第一行只能是“01010...”，否则就是“10101...”。同样算出次数作为答案。
 
-时间复杂度 $O(n^2)$。
+时间复杂度 $O(n^2)$，其中 $n$ 是棋盘的大小。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/0700-0799/0782.Transform to Chessboard/README.md

@@ -68,7 +68,24 @@ The second move swaps the second and third row.
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Pattern Observation + State Compression
+
+In a valid chessboard, there are exactly two types of "rows".
+
+For example, if one row on the chessboard is "01010011", then any other row can only be "01010011" or "10101100". Columns also satisfy this property.
+
+Additionally, each row and each column has half $0$s and half $1$s. Suppose the chessboard is $n \times n$:
+
+-   If $n = 2 \times k$, then each row and each column has $k$ $1$s and $k$ $0$s.
+-   If $n = 2 \times k + 1$, then each row has $k$ $1$s and $k + 1$ $0$s, or $k + 1$ $1$s and $k$ $0$s.
+
+Based on the above conclusions, we can determine whether a chessboard is valid. If valid, we can calculate the minimum number of moves required.
+
+If $n$ is even, there are two possible valid chessboards, where the first row is either "010101..." or "101010...". We calculate the minimum number of swaps required for these two possibilities and take the smaller value as the answer.
+
+If $n$ is odd, there is only one possible valid chessboard. If the number of $0$s in the first row is greater than the number of $1$s, then the first row of the final chessboard must be "01010..."; otherwise, it must be "10101...". We calculate the number of swaps required and use it as the answer.
+
+The time complexity is $O(n^2)$, where $n$ is the size of the chessboard. The space complexity is $O(1)$.
 
 <!-- tabs:start -->