Skip to content

Commit 542c628

Browse files
yanglbmeyanglbme
authored
feat: add Rust solution for lc No.3130 (#5069)
1 parent ec3dbde commit 542c628

4 files changed

Lines changed: 275 additions & 0 deletions

File tree

‎solution/3100-3199/3130.Find All Possible Stable Binary Arrays II/README.md‎

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -252,6 +252,65 @@ func numberOfStableArrays(zero int, one int, limit int) int {
252252
}
253253
```
254254

255+
#### Rust
256+
257+
```rust
258+
impl Solution {
259+
pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
260+
const MOD: i64 = 1_000_000_007;
261+
262+
fn dfs(
263+
i: i32,
264+
j: i32,
265+
k: usize,
266+
limit: i32,
267+
f: &mut Vec<Vec<[i64; 2]>>,
268+
) -> i64 {
269+
if i < 0 || j < 0 {
270+
return 0;
271+
}
272+
273+
if i == 0 {
274+
return if k == 1 && j <= limit { 1 } else { 0 };
275+
}
276+
277+
if j == 0 {
278+
return if k == 0 && i <= limit { 1 } else { 0 };
279+
}
280+
281+
let (iu, ju) = (i as usize, j as usize);
282+
283+
if f[iu][ju][k] != -1 {
284+
return f[iu][ju][k];
285+
}
286+
287+
let res = if k == 0 {
288+
(
289+
dfs(i - 1, j, 0, limit, f)
290+
+ dfs(i - 1, j, 1, limit, f)
291+
- dfs(i - limit - 1, j, 1, limit, f)
292+
+ MOD
293+
) % MOD
294+
} else {
295+
(
296+
dfs(i, j - 1, 0, limit, f)
297+
+ dfs(i, j - 1, 1, limit, f)
298+
- dfs(i, j - limit - 1, 0, limit, f)
299+
+ MOD
300+
) % MOD
301+
};
302+
303+
f[iu][ju][k] = res;
304+
res
305+
}
306+
307+
let mut f = vec![vec![[-1_i64; 2]; (one + 1) as usize]; (zero + 1) as usize];
308+
309+
((dfs(zero, one, 0, limit, &mut f) + dfs(zero, one, 1, limit, &mut f)) % MOD) as i32
310+
}
311+
}
312+
```
313+
255314
<!-- tabs:end -->
256315

257316
<!-- solution:end -->
@@ -410,6 +469,42 @@ function numberOfStableArrays(zero: number, one: number, limit: number): number
410469
}
411470
```
412471

472+
#### Rust
473+
474+
```rust
475+
impl Solution {
476+
pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
477+
let mod_: i64 = 1_000_000_007;
478+
479+
let zero = zero as usize;
480+
let one = one as usize;
481+
let limit = limit as usize;
482+
483+
let mut f = vec![vec![[0_i64; 2]; one + 1]; zero + 1];
484+
485+
for i in 1..=zero.min(limit) {
486+
f[i][0][0] = 1;
487+
}
488+
489+
for j in 1..=one.min(limit) {
490+
f[0][j][1] = 1;
491+
}
492+
493+
for i in 1..=zero {
494+
for j in 1..=one {
495+
let x = if i > limit { f[i - limit - 1][j][1] } else { 0 };
496+
let y = if j > limit { f[i][j - limit - 1][0] } else { 0 };
497+
498+
f[i][j][0] = (f[i - 1][j][0] + f[i - 1][j][1] - x + mod_) % mod_;
499+
f[i][j][1] = (f[i][j - 1][0] + f[i][j - 1][1] - y + mod_) % mod_;
500+
}
501+
}
502+
503+
((f[zero][one][0] + f[zero][one][1]) % mod_) as i32
504+
}
505+
}
506+
```
507+
413508
<!-- tabs:end -->
414509

415510
<!-- solution:end -->

‎solution/3100-3199/3130.Find All Possible Stable Binary Arrays II/README_EN.md‎

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -243,6 +243,65 @@ func numberOfStableArrays(zero int, one int, limit int) int {
243243
}
244244
```
245245

246+
#### Rust
247+
248+
```rust
249+
impl Solution {
250+
pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
251+
const MOD: i64 = 1_000_000_007;
252+
253+
fn dfs(
254+
i: i32,
255+
j: i32,
256+
k: usize,
257+
limit: i32,
258+
f: &mut Vec<Vec<[i64; 2]>>,
259+
) -> i64 {
260+
if i < 0 || j < 0 {
261+
return 0;
262+
}
263+
264+
if i == 0 {
265+
return if k == 1 && j <= limit { 1 } else { 0 };
266+
}
267+
268+
if j == 0 {
269+
return if k == 0 && i <= limit { 1 } else { 0 };
270+
}
271+
272+
let (iu, ju) = (i as usize, j as usize);
273+
274+
if f[iu][ju][k] != -1 {
275+
return f[iu][ju][k];
276+
}
277+
278+
let res = if k == 0 {
279+
(
280+
dfs(i - 1, j, 0, limit, f)
281+
+ dfs(i - 1, j, 1, limit, f)
282+
- dfs(i - limit - 1, j, 1, limit, f)
283+
+ MOD
284+
) % MOD
285+
} else {
286+
(
287+
dfs(i, j - 1, 0, limit, f)
288+
+ dfs(i, j - 1, 1, limit, f)
289+
- dfs(i, j - limit - 1, 0, limit, f)
290+
+ MOD
291+
) % MOD
292+
};
293+
294+
f[iu][ju][k] = res;
295+
res
296+
}
297+
298+
let mut f = vec![vec![[-1_i64; 2]; (one + 1) as usize]; (zero + 1) as usize];
299+
300+
((dfs(zero, one, 0, limit, &mut f) + dfs(zero, one, 1, limit, &mut f)) % MOD) as i32
301+
}
302+
}
303+
```
304+
246305
<!-- tabs:end -->
247306

248307
<!-- solution:end -->
@@ -401,6 +460,42 @@ function numberOfStableArrays(zero: number, one: number, limit: number): number
401460
}
402461
```
403462

463+
#### Rust
464+
465+
```rust
466+
impl Solution {
467+
pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
468+
let mod_: i64 = 1_000_000_007;
469+
470+
let zero = zero as usize;
471+
let one = one as usize;
472+
let limit = limit as usize;
473+
474+
let mut f = vec![vec![[0_i64; 2]; one + 1]; zero + 1];
475+
476+
for i in 1..=zero.min(limit) {
477+
f[i][0][0] = 1;
478+
}
479+
480+
for j in 1..=one.min(limit) {
481+
f[0][j][1] = 1;
482+
}
483+
484+
for i in 1..=zero {
485+
for j in 1..=one {
486+
let x = if i > limit { f[i - limit - 1][j][1] } else { 0 };
487+
let y = if j > limit { f[i][j - limit - 1][0] } else { 0 };
488+
489+
f[i][j][0] = (f[i - 1][j][0] + f[i - 1][j][1] - x + mod_) % mod_;
490+
f[i][j][1] = (f[i][j - 1][0] + f[i][j - 1][1] - y + mod_) % mod_;
491+
}
492+
}
493+
494+
((f[zero][one][0] + f[zero][one][1]) % mod_) as i32
495+
}
496+
}
497+
```
498+
404499
<!-- tabs:end -->
405500

406501
<!-- solution:end -->

‎solution/3100-3199/3130.Find All Possible Stable Binary Arrays II/Solution.rs‎

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
impl Solution {
2+
pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
3+
const MOD: i64 = 1_000_000_007;
4+
5+
fn dfs(
6+
i: i32,
7+
j: i32,
8+
k: usize,
9+
limit: i32,
10+
f: &mut Vec<Vec<[i64; 2]>>,
11+
) -> i64 {
12+
if i < 0 || j < 0 {
13+
return 0;
14+
}
15+
16+
if i == 0 {
17+
return if k == 1 && j <= limit { 1 } else { 0 };
18+
}
19+
20+
if j == 0 {
21+
return if k == 0 && i <= limit { 1 } else { 0 };
22+
}
23+
24+
let (iu, ju) = (i as usize, j as usize);
25+
26+
if f[iu][ju][k] != -1 {
27+
return f[iu][ju][k];
28+
}
29+
30+
let res = if k == 0 {
31+
(
32+
dfs(i - 1, j, 0, limit, f)
33+
+ dfs(i - 1, j, 1, limit, f)
34+
- dfs(i - limit - 1, j, 1, limit, f)
35+
+ MOD
36+
) % MOD
37+
} else {
38+
(
39+
dfs(i, j - 1, 0, limit, f)
40+
+ dfs(i, j - 1, 1, limit, f)
41+
- dfs(i, j - limit - 1, 0, limit, f)
42+
+ MOD
43+
) % MOD
44+
};
45+
46+
f[iu][ju][k] = res;
47+
res
48+
}
49+
50+
let mut f = vec![vec![[-1_i64; 2]; (one + 1) as usize]; (zero + 1) as usize];
51+
52+
((dfs(zero, one, 0, limit, &mut f) + dfs(zero, one, 1, limit, &mut f)) % MOD) as i32
53+
}
54+
}

‎solution/3100-3199/3130.Find All Possible Stable Binary Arrays II/Solution2.rs‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
impl Solution {
2+
pub fn number_of_stable_arrays(zero: i32, one: i32, limit: i32) -> i32 {
3+
let mod_: i64 = 1_000_000_007;
4+
5+
let zero = zero as usize;
6+
let one = one as usize;
7+
let limit = limit as usize;
8+
9+
let mut f = vec![vec![[0_i64; 2]; one + 1]; zero + 1];
10+
11+
for i in 1..=zero.min(limit) {
12+
f[i][0][0] = 1;
13+
}
14+
15+
for j in 1..=one.min(limit) {
16+
f[0][j][1] = 1;
17+
}
18+
19+
for i in 1..=zero {
20+
for j in 1..=one {
21+
let x = if i > limit { f[i - limit - 1][j][1] } else { 0 };
22+
let y = if j > limit { f[i][j - limit - 1][0] } else { 0 };
23+
24+
f[i][j][0] = (f[i - 1][j][0] + f[i - 1][j][1] - x + mod_) % mod_;
25+
f[i][j][1] = (f[i][j - 1][0] + f[i][j - 1][1] - y + mod_) % mod_;
26+
}
27+
}
28+
29+
((f[zero][one][0] + f[zero][one][1]) % mod_) as i32
30+
}
31+
}

0 commit comments

Comments
 (0)