feat: add Rust solution for lc No.3129 (#5068)

Author: yanglbme

solution/3100-3199/3129.Find All Possible Stable Binary Arrays I/README.md

@@ -89,19 +89,19 @@ tags:
 
 ### 方法一：记忆化搜索
 
-我们设计一个函数 $dfs(i, j, k)$ 表示还剩下 $i$ 个 $0$ 和 $j$ 个 $1$ 且接下来待填的数字是 $k$ 的情况下，满足题目条件的稳定二进制数组的个数。那么答案就是 $dfs(zero, one, 0) + dfs(zero, one, 1)$。
+我们设计一个函数 $\textit{dfs}(i, j, k)$ 表示还剩下 $i$ 个 $0$ 和 $j$ 个 $1$ 且接下来待填的数字是 $k$ 的情况下，满足题目条件的稳定二进制数组的个数。那么答案就是 $\textit{dfs}(\textit{zero}, \textit{one}, 0) + \textit{dfs}(\textit{zero}, \textit{one}, 1)$。
 
-函数 $dfs(i, j, k)$ 的计算过程如下：
+函数 $\textit{dfs}(i, j, k)$ 的计算过程如下：
 
 - 如果 $i \lt 0$ 或 $j \lt 0$，返回 $0$。
 - 如果 $i = 0$，那么当 $k = 1$ 且 $j \leq \textit{limit}$ 时返回 $1$，否则返回 $0$。
 - 如果 $j = 0$，那么当 $k = 0$ 且 $i \leq \textit{limit}$ 时返回 $1$，否则返回 $0$。
-- 如果 $k = 0$，我们考虑前一个数字是 $0$ 的情况 $dfs(i - 1, j, 0)$ 和前一个数字是 $1$ 的情况 $dfs(i - 1, j, 1)$，如果前一个数是 $0$，那么有可能使得子数组中有超过 $\textit{limit}$ 个 $0$，即不允许出现倒数第 $\textit{limit} + 1$ 个数是 $1$ 的情况，所以我们要减去这种情况，即 $dfs(i - \textit{limit} - 1, j, 1)$。
-- 如果 $k = 1$，我们考虑前一个数字是 $0$ 的情况 $dfs(i, j - 1, 0)$ 和前一个数字是 $1$ 的情况 $dfs(i, j - 1, 1)$，如果前一个数是 $1$，那么有可能使得子数组中有超过 $\textit{limit}$ 个 $1$，即不允许出现倒数第 $\textit{limit} + 1$ 个数是 $0$ 的情况，所以我们要减去这种情况，即 $dfs(i, j - \textit{limit} - 1, 0)$。
+- 如果 $k = 0$，我们考虑前一个数字是 $0$ 的情况 $\textit{dfs}(i - 1, j, 0)$ 和前一个数字是 $1$ 的情况 $\textit{dfs}(i - 1, j, 1)$，如果前一个数是 $0$，那么有可能使得子数组中有超过 $\textit{limit}$ 个 $0$，即不允许出现倒数第 $\textit{limit} + 1$ 个数是 $1$ 的情况，所以我们要减去这种情况，即 $\textit{dfs}(i - \textit{limit} - 1, j, 1)$。
+- 如果 $k = 1$，我们考虑前一个数字是 $0$ 的情况 $\textit{dfs}(i, j - 1, 0)$ 和前一个数字是 $1$ 的情况 $\textit{dfs}(i, j - 1, 1)$，如果前一个数是 $1$，那么有可能使得子数组中有超过 $\textit{limit}$ 个 $1$，即不允许出现倒数第 $\textit{limit} + 1$ 个数是 $0$ 的情况，所以我们要减去这种情况，即 $\textit{dfs}(i, j - \textit{limit} - 1, 0)$。
 
 为了避免重复计算，我们使用记忆化搜索的方法。
 
-时间复杂度 $O(zero \times one)$，空间复杂度 $O(zero \times one)$。
+时间复杂度 $O(\textit{zero} \times \textit{one})$，空间复杂度 $O(\textit{zero} \times \textit{one})$。
 
 <!-- tabs:start -->
 
@@ -287,6 +287,65 @@ function numberOfStableArrays(zero: number, one: number, limit: number): number
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
+        const MOD: i64 = 1_000_000_007;
+
+        fn dfs(
+            i: i32,
+            j: i32,
+            k: usize,
+            limit: i32,
+            f: &mut Vec<Vec<[i64; 2]>>,
+        ) -> i64 {
+            if i < 0 || j < 0 {
+                return 0;
+            }
+
+            if i == 0 {
+                return if k == 1 && j <= limit { 1 } else { 0 };
+            }
+
+            if j == 0 {
+                return if k == 0 && i <= limit { 1 } else { 0 };
+            }
+
+            let (iu, ju) = (i as usize, j as usize);
+
+            if f[iu][ju][k] != -1 {
+                return f[iu][ju][k];
+            }
+
+            let res = if k == 0 {
+                (
+                    dfs(i - 1, j, 0, limit, f)
+                    + dfs(i - 1, j, 1, limit, f)
+                    - dfs(i - limit - 1, j, 1, limit, f)
+                    + MOD
+                ) % MOD
+            } else {
+                (
+                    dfs(i, j - 1, 0, limit, f)
+                    + dfs(i, j - 1, 1, limit, f)
+                    - dfs(i, j - limit - 1, 0, limit, f)
+                    + MOD
+                ) % MOD
+            };
+
+            f[iu][ju][k] = res;
+            res
+        }
+
+        let mut f = vec![vec![[-1_i64; 2]; (one + 1) as usize]; (zero + 1) as usize];
+
+        ((dfs(zero, one, 0, limit, &mut f) + dfs(zero, one, 1, limit, &mut f)) % MOD) as i32
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
@@ -306,7 +365,7 @@ function numberOfStableArrays(zero: number, one: number, limit: number): number
 - $f[i][j][0] = f[i - 1][j][0] + f[i - 1][j][1] - f[i - \textit{limit} - 1][j][1]$。
 - $f[i][j][1] = f[i][j - 1][0] + f[i][j - 1][1] - f[i][j - \textit{limit} - 1][0]$。
 
-时间复杂度 $O(zero \times one)$，空间复杂度 $O(zero \times one)$。
+时间复杂度 $O(\textit{zero} \times \textit{one})$，空间复杂度 $O(\textit{zero} \times \textit{one})$。
 
 <!-- tabs:start -->
 
@@ -445,6 +504,42 @@ function numberOfStableArrays(zero: number, one: number, limit: number): number
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
+        let mod_: i64 = 1_000_000_007;
+
+        let zero = zero as usize;
+        let one = one as usize;
+        let limit = limit as usize;
+
+        let mut f = vec![vec![[0_i64; 2]; one + 1]; zero + 1];
+
+        for i in 1..=zero.min(limit) {
+            f[i][0][0] = 1;
+        }
+
+        for j in 1..=one.min(limit) {
+            f[0][j][1] = 1;
+        }
+
+        for i in 1..=zero {
+            for j in 1..=one {
+                let x = if i > limit { f[i - limit - 1][j][1] } else { 0 };
+                let y = if j > limit { f[i][j - limit - 1][0] } else { 0 };
+
+                f[i][j][0] = (f[i - 1][j][0] + f[i - 1][j][1] - x + mod_) % mod_;
+                f[i][j][1] = (f[i][j - 1][0] + f[i][j - 1][1] - y + mod_) % mod_;
+            }
+        }
+
+        ((f[zero][one][0] + f[zero][one][1]) % mod_) as i32
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3100-3199/3129.Find All Possible Stable Binary Arrays I/README_EN.md

@@ -85,16 +85,21 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1: Memoization Search
+### Solution 1: Memoized Search
 
-We design a function $dfs(i, j, k)$ to represent the number of stable binary arrays that satisfy the problem conditions when there are $i$ $0$s and $j$ $1$s left, and the next number to be filled is $k$. The answer is $dfs(zero, one, 0) + dfs(zero, one, 1)$.
+We define a function $\textit{dfs}(i, j, k)$ to represent the number of stable binary arrays that satisfy the problem conditions when there are $i$ zeros and $j$ ones remaining to place, and the next digit to fill is $k$. Then the answer is $\textit{dfs}(\textit{zero}, \textit{one}, 0) + \textit{dfs}(\textit{zero}, \textit{one}, 1)$.
 
-The calculation process of the function $dfs(i, j, k)$ is as follows:
+The computation process of $\textit{dfs}(i, j, k)$ is as follows:
 
-- If $i < 0$ or $j < 0$, return $0$.
-- If $i = 0$, return $1$ when $k = 1$ and $j \leq \textit{limit}$, otherwise return $0$.
-- If $j = 0$, return $1$ when $k = 0$ and $i \leq \textit{limit}$, otherwise return $0$.
-- If $k = 0$, we consider the case where the previous number is $0$, $dfs(i - 1, j, 0)$, and the case where the previous number is $1$, $dfs(i - 1, j, 1)$. If the previous number is $0$, it may cause more than $\textit{limit}$ $0$s in the subarray, i.e., the situation where the $\textit{limit} + 1$
+- If $i \lt 0$ or $j \lt 0$, return $0$.
+- If $i = 0$, then return $1$ when $k = 1$ and $j \leq \textit{limit}$; otherwise return $0$.
+- If $j = 0$, then return $1$ when $k = 0$ and $i \leq \textit{limit}$; otherwise return $0$.
+- If $k = 0$, we consider the case where the previous digit is $0$, i.e., $\textit{dfs}(i - 1, j, 0)$, and the case where the previous digit is $1$, i.e., $\textit{dfs}(i - 1, j, 1)$. If the previous digit is $0$, there may be more than $\textit{limit}$ zeros in a subarray, which means the case where the $(\textit{limit} + 1)$-th digit from the end is $1$ is invalid, so we subtract this case: $\textit{dfs}(i - \textit{limit} - 1, j, 1)$.
+- If $k = 1$, we consider the case where the previous digit is $0$, i.e., $\textit{dfs}(i, j - 1, 0)$, and the case where the previous digit is $1$, i.e., $\textit{dfs}(i, j - 1, 1)$. If the previous digit is $1$, there may be more than $\textit{limit}$ ones in a subarray, which means the case where the $(\textit{limit} + 1)$-th digit from the end is $0$ is invalid, so we subtract this case: $\textit{dfs}(i, j - \textit{limit} - 1, 0)$.
+
+To avoid repeated computation, we use memoized search.
+
+The time complexity is $O(\textit{zero} \times \textit{one})$, and the space complexity is $O(\textit{zero} \times \textit{one})$.
 
 <!-- tabs:start -->
 
@@ -278,6 +283,65 @@ function numberOfStableArrays(zero: number, one: number, limit: number): number
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
+        const MOD: i64 = 1_000_000_007;
+
+        fn dfs(
+            i: i32,
+            j: i32,
+            k: usize,
+            limit: i32,
+            f: &mut Vec<Vec<[i64; 2]>>,
+        ) -> i64 {
+            if i < 0 || j < 0 {
+                return 0;
+            }
+
+            if i == 0 {
+                return if k == 1 && j <= limit { 1 } else { 0 };
+            }
+
+            if j == 0 {
+                return if k == 0 && i <= limit { 1 } else { 0 };
+            }
+
+            let (iu, ju) = (i as usize, j as usize);
+
+            if f[iu][ju][k] != -1 {
+                return f[iu][ju][k];
+            }
+
+            let res = if k == 0 {
+                (
+                    dfs(i - 1, j, 0, limit, f)
+                    + dfs(i - 1, j, 1, limit, f)
+                    - dfs(i - limit - 1, j, 1, limit, f)
+                    + MOD
+                ) % MOD
+            } else {
+                (
+                    dfs(i, j - 1, 0, limit, f)
+                    + dfs(i, j - 1, 1, limit, f)
+                    - dfs(i, j - limit - 1, 0, limit, f)
+                    + MOD
+                ) % MOD
+            };
+
+            f[iu][ju][k] = res;
+            res
+        }
+
+        let mut f = vec![vec![[-1_i64; 2]; (one + 1) as usize]; (zero + 1) as usize];
+
+        ((dfs(zero, one, 0, limit, &mut f) + dfs(zero, one, 1, limit, &mut f)) % MOD) as i32
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
@@ -286,18 +350,18 @@ function numberOfStableArrays(zero: number, one: number, limit: number): number
 
 ### Solution 2: Dynamic Programming
 
-We can also convert the memoization search of Solution 1 into dynamic programming.
+We can also convert the memoized search in Solution 1 into dynamic programming.
 
-We define $f[i][j][k]$ as the number of stable binary arrays using $i$ $0$s and $j$ $1$s, and the last number is $k$. So the answer is $f[zero][one][0] + f[zero][one][1]$.
+We define $f[i][j][k]$ as the number of stable binary arrays that use $i$ zeros and $j$ ones, with the last digit being $k$. Then the answer is $f[zero][one][0] + f[zero][one][1]$.
 
 Initially, we have $f[i][0][0] = 1$, where $1 \leq i \leq \min(\textit{limit}, \textit{zero})$; and $f[0][j][1] = 1$, where $1 \leq j \leq \min(\textit{limit}, \textit{one})$.
 
-The state transition equation is as follows:
+The state transition equations are as follows:
 
 - $f[i][j][0] = f[i - 1][j][0] + f[i - 1][j][1] - f[i - \textit{limit} - 1][j][1]$.
 - $f[i][j][1] = f[i][j - 1][0] + f[i][j - 1][1] - f[i][j - \textit{limit} - 1][0]$.
 
-The time complexity is $O(zero \times one)$, and the space complexity is $O(zero \times one)$.
+The time complexity is $O(\textit{zero} \times \textit{one})$, and the space complexity is $O(\textit{zero} \times \textit{one})$.
 
 <!-- tabs:start -->
 
@@ -436,6 +500,42 @@ function numberOfStableArrays(zero: number, one: number, limit: number): number
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
+        let mod_: i64 = 1_000_000_007;
+
+        let zero = zero as usize;
+        let one = one as usize;
+        let limit = limit as usize;
+
+        let mut f = vec![vec![[0_i64; 2]; one + 1]; zero + 1];
+
+        for i in 1..=zero.min(limit) {
+            f[i][0][0] = 1;
+        }
+
+        for j in 1..=one.min(limit) {
+            f[0][j][1] = 1;
+        }
+
+        for i in 1..=zero {
+            for j in 1..=one {
+                let x = if i > limit { f[i - limit - 1][j][1] } else { 0 };
+                let y = if j > limit { f[i][j - limit - 1][0] } else { 0 };
+
+                f[i][j][0] = (f[i - 1][j][0] + f[i - 1][j][1] - x + mod_) % mod_;
+                f[i][j][1] = (f[i][j - 1][0] + f[i][j - 1][1] - y + mod_) % mod_;
+            }
+        }
+
+        ((f[zero][one][0] + f[zero][one][1]) % mod_) as i32
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3100-3199/3129.Find All Possible Stable Binary Arrays I/Solution.rs

@@ -0,0 +1,54 @@
+impl Solution {
+    pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
+        const MOD: i64 = 1_000_000_007;
+
+        fn dfs(
+            i: i32,
+            j: i32,
+            k: usize,
+            limit: i32,
+            f: &mut Vec<Vec<[i64; 2]>>,
+        ) -> i64 {
+            if i < 0 || j < 0 {
+                return 0;
+            }
+
+            if i == 0 {
+                return if k == 1 && j <= limit { 1 } else { 0 };
+            }
+
+            if j == 0 {
+                return if k == 0 && i <= limit { 1 } else { 0 };
+            }
+
+            let (iu, ju) = (i as usize, j as usize);
+
+            if f[iu][ju][k] != -1 {
+                return f[iu][ju][k];
+            }
+
+            let res = if k == 0 {
+                (
+                    dfs(i - 1, j, 0, limit, f)
+                    + dfs(i - 1, j, 1, limit, f)
+                    - dfs(i - limit - 1, j, 1, limit, f)
+                    + MOD
+                ) % MOD
+            } else {
+                (
+                    dfs(i, j - 1, 0, limit, f)
+                    + dfs(i, j - 1, 1, limit, f)
+                    - dfs(i, j - limit - 1, 0, limit, f)
+                    + MOD
+                ) % MOD
+            };
+
+            f[iu][ju][k] = res;
+            res
+        }
+
+        let mut f = vec![vec![[-1_i64; 2]; (one + 1) as usize]; (zero + 1) as usize];
+
+        ((dfs(zero, one, 0, limit, &mut f) + dfs(zero, one, 1, limit, &mut f)) % MOD) as i32
+    }
+}

solution/3100-3199/3129.Find All Possible Stable Binary Arrays I/Solution2.rs

@@ -0,0 +1,31 @@
+impl Solution {
+    pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
+        let mod_: i64 = 1_000_000_007;
+
+        let zero = zero as usize;
+        let one = one as usize;
+        let limit = limit as usize;
+
+        let mut f = vec![vec![[0_i64; 2]; one + 1]; zero + 1];
+
+        for i in 1..=zero.min(limit) {
+            f[i][0][0] = 1;
+        }
+
+        for j in 1..=one.min(limit) {
+            f[0][j][1] = 1;
+        }
+
+        for i in 1..=zero {
+            for j in 1..=one {
+                let x = if i > limit { f[i - limit - 1][j][1] } else { 0 };
+                let y = if j > limit { f[i][j - limit - 1][0] } else { 0 };
+
+                f[i][j][0] = (f[i - 1][j][0] + f[i - 1][j][1] - x + mod_) % mod_;
+                f[i][j][1] = (f[i][j - 1][0] + f[i][j - 1][1] - y + mod_) % mod_;
+            }
+        }
+
+        ((f[zero][one][0] + f[zero][one][1]) % mod_) as i32
+    }
+}