feat: add rust solutions to lc problems: No.3573,3577,3578 (#4484)

Author: yanglbme

solution/3500-3599/3573.Best Time to Buy and Sell Stock V/README.md

@@ -254,6 +254,32 @@ function maximumProfit(prices: number[], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_profit(prices: Vec<i32>, k: i32) -> i64 {
+        let n = prices.len();
+        let k = k as usize;
+        let mut f = vec![vec![vec![0i64; 3]; k + 1]; n];
+        for j in 1..=k {
+            f[0][j][1] = -(prices[0] as i64);
+            f[0][j][2] = prices[0] as i64;
+        }
+        for i in 1..n {
+            for j in 1..=k {
+                f[i][j][0] = f[i - 1][j][0]
+                    .max(f[i - 1][j][1] + prices[i] as i64)
+                    .max(f[i - 1][j][2] - prices[i] as i64);
+                f[i][j][1] = f[i - 1][j][1].max(f[i - 1][j - 1][0] - prices[i] as i64);
+                f[i][j][2] = f[i - 1][j][2].max(f[i - 1][j - 1][0] + prices[i] as i64);
+            }
+        }
+        f[n - 1][k][0]
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3573.Best Time to Buy and Sell Stock V/README_EN.md

@@ -252,6 +252,32 @@ function maximumProfit(prices: number[], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_profit(prices: Vec<i32>, k: i32) -> i64 {
+        let n = prices.len();
+        let k = k as usize;
+        let mut f = vec![vec![vec![0i64; 3]; k + 1]; n];
+        for j in 1..=k {
+            f[0][j][1] = -(prices[0] as i64);
+            f[0][j][2] = prices[0] as i64;
+        }
+        for i in 1..n {
+            for j in 1..=k {
+                f[i][j][0] = f[i - 1][j][0]
+                    .max(f[i - 1][j][1] + prices[i] as i64)
+                    .max(f[i - 1][j][2] - prices[i] as i64);
+                f[i][j][1] = f[i - 1][j][1].max(f[i - 1][j - 1][0] - prices[i] as i64);
+                f[i][j][2] = f[i - 1][j][2].max(f[i - 1][j - 1][0] + prices[i] as i64);
+            }
+        }
+        f[n - 1][k][0]
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3573.Best Time to Buy and Sell Stock V/Solution.rs

@@ -0,0 +1,21 @@
+impl Solution {
+    pub fn maximum_profit(prices: Vec<i32>, k: i32) -> i64 {
+        let n = prices.len();
+        let k = k as usize;
+        let mut f = vec![vec![vec![0i64; 3]; k + 1]; n];
+        for j in 1..=k {
+            f[0][j][1] = -(prices[0] as i64);
+            f[0][j][2] = prices[0] as i64;
+        }
+        for i in 1..n {
+            for j in 1..=k {
+                f[i][j][0] = f[i - 1][j][0]
+                    .max(f[i - 1][j][1] + prices[i] as i64)
+                    .max(f[i - 1][j][2] - prices[i] as i64);
+                f[i][j][1] = f[i - 1][j][1].max(f[i - 1][j - 1][0] - prices[i] as i64);
+                f[i][j][2] = f[i - 1][j][2].max(f[i - 1][j - 1][0] + prices[i] as i64);
+            }
+        }
+        f[n - 1][k][0]
+    }
+}

solution/3500-3599/3576.Transform Array to All Equal Elements/README.md

@@ -203,6 +203,31 @@ function canMakeEqual(nums: number[], k: number): boolean {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn can_make_equal(nums: Vec<i32>, k: i32) -> bool {
+        fn check(target: i32, k: i32, nums: &Vec<i32>) -> bool {
+            let mut cnt = 0;
+            let mut sign = 1;
+            for i in 0..nums.len() - 1 {
+                let x = nums[i] * sign;
+                if x == target {
+                    sign = 1;
+                } else {
+                    sign = -1;
+                    cnt += 1;
+                }
+            }
+            cnt <= k && nums[nums.len() - 1] * sign == target
+        }
+
+        check(nums[0], k, &nums) || check(-nums[0], k, &nums)
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3576.Transform Array to All Equal Elements/README_EN.md

@@ -201,6 +201,31 @@ function canMakeEqual(nums: number[], k: number): boolean {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn can_make_equal(nums: Vec<i32>, k: i32) -> bool {
+        fn check(target: i32, k: i32, nums: &Vec<i32>) -> bool {
+            let mut cnt = 0;
+            let mut sign = 1;
+            for i in 0..nums.len() - 1 {
+                let x = nums[i] * sign;
+                if x == target {
+                    sign = 1;
+                } else {
+                    sign = -1;
+                    cnt += 1;
+                }
+            }
+            cnt <= k && nums[nums.len() - 1] * sign == target
+        }
+
+        check(nums[0], k, &nums) || check(-nums[0], k, &nums)
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.rs

@@ -0,0 +1,20 @@
+impl Solution {
+    pub fn can_make_equal(nums: Vec<i32>, k: i32) -> bool {
+        fn check(target: i32, k: i32, nums: &Vec<i32>) -> bool {
+            let mut cnt = 0;
+            let mut sign = 1;
+            for i in 0..nums.len() - 1 {
+                let x = nums[i] * sign;
+                if x == target {
+                    sign = 1;
+                } else {
+                    sign = -1;
+                    cnt += 1;
+                }
+            }
+            cnt <= k && nums[nums.len() - 1] * sign == target
+        }
+
+        check(nums[0], k, &nums) || check(-nums[0], k, &nums)
+    }
+}

solution/3500-3599/3577.Count the Number of Computer Unlocking Permutations/README.md

@@ -187,6 +187,24 @@ function countPermutations(complexity: number[]): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn count_permutations(complexity: Vec<i32>) -> i32 {
+        const MOD: i64 = 1_000_000_007;
+        let mut ans = 1i64;
+        for i in 1..complexity.len() {
+            if complexity[i] <= complexity[0] {
+                return 0;
+            }
+            ans = ans * i as i64 % MOD;
+        }
+        ans as i32
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3577.Count the Number of Computer Unlocking Permutations/README_EN.md

@@ -183,6 +183,24 @@ function countPermutations(complexity: number[]): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn count_permutations(complexity: Vec<i32>) -> i32 {
+        const MOD: i64 = 1_000_000_007;
+        let mut ans = 1i64;
+        for i in 1..complexity.len() {
+            if complexity[i] <= complexity[0] {
+                return 0;
+            }
+            ans = ans * i as i64 % MOD;
+        }
+        ans as i32
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3577.Count the Number of Computer Unlocking Permutations/Solution.rs

@@ -0,0 +1,13 @@
+impl Solution {
+    pub fn count_permutations(complexity: Vec<i32>) -> i32 {
+        const MOD: i64 = 1_000_000_007;
+        let mut ans = 1i64;
+        for i in 1..complexity.len() {
+            if complexity[i] <= complexity[0] {
+                return 0;
+            }
+            ans = ans * i as i64 % MOD;
+        }
+        ans as i32
+    }
+}

solution/3500-3599/3578.Count Partitions With Max-Min Difference at Most K/README.md

@@ -854,6 +854,42 @@ class TreapMultiSet<T = number> implements ITreapMultiSet<T> {
 }
 ```
 
+#### Rust
+
+```rust
+ use std::collections::BTreeMap;
+
+impl Solution {
+    pub fn count_partitions(nums: Vec<i32>, k: i32) -> i32 {
+        const mod_val: i32 = 1_000_000_007;
+        let n = nums.len();
+        let mut f = vec![0; n + 1];
+        let mut g = vec![0; n + 1];
+        f[0] = 1;
+        g[0] = 1;
+        let mut sl = BTreeMap::new();
+        let mut l = 1;
+        for r in 1..=n {
+            let x = nums[r - 1];
+            *sl.entry(x).or_insert(0) += 1;
+            while sl.keys().last().unwrap() - sl.keys().next().unwrap() > k {
+                let val = nums[l - 1];
+                if let Some(cnt) = sl.get_mut(&val) {
+                    *cnt -= 1;
+                    if *cnt == 0 {
+                        sl.remove(&val);
+                    }
+                }
+                l += 1;
+            }
+            f[r] = (g[r - 1] - if l >= 2 { g[l - 2] } else { 0 } + mod_val) % mod_val;
+            g[r] = (g[r - 1] + f[r]) % mod_val;
+        }
+        f[n]
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3578.Count Partitions With Max-Min Difference at Most K/README_EN.md

@@ -851,6 +851,42 @@ class TreapMultiSet<T = number> implements ITreapMultiSet<T> {
 }
 ```
 
+#### Rust
+
+```rust
+use std::collections::BTreeMap;
+
+impl Solution {
+    pub fn count_partitions(nums: Vec<i32>, k: i32) -> i32 {
+        const mod_val: i32 = 1_000_000_007;
+        let n = nums.len();
+        let mut f = vec![0; n + 1];
+        let mut g = vec![0; n + 1];
+        f[0] = 1;
+        g[0] = 1;
+        let mut sl = BTreeMap::new();
+        let mut l = 1;
+        for r in 1..=n {
+            let x = nums[r - 1];
+            *sl.entry(x).or_insert(0) += 1;
+            while sl.keys().last().unwrap() - sl.keys().next().unwrap() > k {
+                let val = nums[l - 1];
+                if let Some(cnt) = sl.get_mut(&val) {
+                    *cnt -= 1;
+                    if *cnt == 0 {
+                        sl.remove(&val);
+                    }
+                }
+                l += 1;
+            }
+            f[r] = (g[r - 1] - if l >= 2 { g[l - 2] } else { 0 } + mod_val) % mod_val;
+            g[r] = (g[r - 1] + f[r]) % mod_val;
+        }
+        f[n]
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3578.Count Partitions With Max-Min Difference at Most K/Solution.rs

@@ -0,0 +1,31 @@
+use std::collections::BTreeMap;
+
+impl Solution {
+    pub fn count_partitions(nums: Vec<i32>, k: i32) -> i32 {
+        const mod_val: i32 = 1_000_000_007;
+        let n = nums.len();
+        let mut f = vec![0; n + 1];
+        let mut g = vec![0; n + 1];
+        f[0] = 1;
+        g[0] = 1;
+        let mut sl = BTreeMap::new();
+        let mut l = 1;
+        for r in 1..=n {
+            let x = nums[r - 1];
+            *sl.entry(x).or_insert(0) += 1;
+            while sl.keys().last().unwrap() - sl.keys().next().unwrap() > k {
+                let val = nums[l - 1];
+                if let Some(cnt) = sl.get_mut(&val) {
+                    *cnt -= 1;
+                    if *cnt == 0 {
+                        sl.remove(&val);
+                    }
+                }
+                l += 1;
+            }
+            f[r] = (g[r - 1] - if l >= 2 { g[l - 2] } else { 0 } + mod_val) % mod_val;
+            g[r] = (g[r - 1] + f[r]) % mod_val;
+        }
+        f[n]
+    }
+}