feat: add solutions to lc problems: No.3201,3202

* No.3201.Find the Maximum Length of Valid Subsequence I
* No.3202.Find the Maximum Length of Valid Subsequence II

Author: yanglbme

solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README.md

@@ -201,6 +201,47 @@ function maximumLength(nums: number[]): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_length(nums: Vec<i32>) -> i32 {
+        let mut f = [[0; 2]; 2];
+        let mut ans = 0;
+        for x in nums {
+            let x = (x % 2) as usize;
+            for j in 0..2 {
+                let y = ((j + 2 - x) % 2) as usize;
+                f[x][y] = f[y][x] + 1;
+                ans = ans.max(f[x][y]);
+            }
+        }
+        ans
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int MaximumLength(int[] nums) {
+        int k = 2;
+        int[,] f = new int[k, k];
+        int ans = 0;
+        foreach (int num in nums) {
+            int x = num % k;
+            for (int j = 0; j < k; ++j) {
+                int y = (j - x + k) % k;
+                f[x, y] = f[y, x] + 1;
+                ans = Math.Max(ans, f[x, y]);
+            }
+        }
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README_EN.md

@@ -199,6 +199,47 @@ function maximumLength(nums: number[]): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_length(nums: Vec<i32>) -> i32 {
+        let mut f = [[0; 2]; 2];
+        let mut ans = 0;
+        for x in nums {
+            let x = (x % 2) as usize;
+            for j in 0..2 {
+                let y = ((j + 2 - x) % 2) as usize;
+                f[x][y] = f[y][x] + 1;
+                ans = ans.max(f[x][y]);
+            }
+        }
+        ans
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int MaximumLength(int[] nums) {
+        int k = 2;
+        int[,] f = new int[k, k];
+        int ans = 0;
+        foreach (int num in nums) {
+            int x = num % k;
+            for (int j = 0; j < k; ++j) {
+                int y = (j - x + k) % k;
+                f[x, y] = f[y, x] + 1;
+                ans = Math.Max(ans, f[x, y]);
+            }
+        }
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/Solution.cs

@@ -0,0 +1,16 @@
+public class Solution {
+    public int MaximumLength(int[] nums) {
+        int k = 2;
+        int[,] f = new int[k, k];
+        int ans = 0;
+        foreach (int num in nums) {
+            int x = num % k;
+            for (int j = 0; j < k; ++j) {
+                int y = (j - x + k) % k;
+                f[x, y] = f[y, x] + 1;
+                ans = Math.Max(ans, f[x, y]);
+            }
+        }
+        return ans;
+    }
+}

solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/Solution.rs

@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn maximum_length(nums: Vec<i32>) -> i32 {
+        let mut f = [[0; 2]; 2];
+        let mut ans = 0;
+        for x in nums {
+            let x = (x % 2) as usize;
+            for j in 0..2 {
+                let y = ((j + 2 - x) % 2) as usize;
+                f[x][y] = f[y][x] + 1;
+                ans = ans.max(f[x][y]);
+            }
+        }
+        ans
+    }
+}

solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README.md

@@ -178,6 +178,47 @@ function maximumLength(nums: number[], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_length(nums: Vec<i32>, k: i32) -> i32 {
+        let k = k as usize;
+        let mut f = vec![vec![0; k]; k];
+        let mut ans = 0;
+        for x in nums {
+            let x = (x % k as i32) as usize;
+            for j in 0..k {
+                let y = (j + k - x) % k;
+                f[x][y] = f[y][x] + 1;
+                ans = ans.max(f[x][y]);
+            }
+        }
+        ans
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int MaximumLength(int[] nums, int k) {
+        int[,] f = new int[k, k];
+        int ans = 0;
+        foreach (int num in nums) {
+            int x = num % k;
+            for (int j = 0; j < k; ++j) {
+                int y = (j - x + k) % k;
+                f[x, y] = f[y, x] + 1;
+                ans = Math.Max(ans, f[x, y]);
+            }
+        }
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README_EN.md

@@ -177,6 +177,47 @@ function maximumLength(nums: number[], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_length(nums: Vec<i32>, k: i32) -> i32 {
+        let k = k as usize;
+        let mut f = vec![vec![0; k]; k];
+        let mut ans = 0;
+        for x in nums {
+            let x = (x % k as i32) as usize;
+            for j in 0..k {
+                let y = (j + k - x) % k;
+                f[x][y] = f[y][x] + 1;
+                ans = ans.max(f[x][y]);
+            }
+        }
+        ans
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int MaximumLength(int[] nums, int k) {
+        int[,] f = new int[k, k];
+        int ans = 0;
+        foreach (int num in nums) {
+            int x = num % k;
+            for (int j = 0; j < k; ++j) {
+                int y = (j - x + k) % k;
+                f[x, y] = f[y, x] + 1;
+                ans = Math.Max(ans, f[x, y]);
+            }
+        }
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/Solution.cs

@@ -0,0 +1,15 @@
+public class Solution {
+    public int MaximumLength(int[] nums, int k) {
+        int[,] f = new int[k, k];
+        int ans = 0;
+        foreach (int num in nums) {
+            int x = num % k;
+            for (int j = 0; j < k; ++j) {
+                int y = (j - x + k) % k;
+                f[x, y] = f[y, x] + 1;
+                ans = Math.Max(ans, f[x, y]);
+            }
+        }
+        return ans;
+    }
+}

solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/Solution.rs

@@ -0,0 +1,16 @@
+impl Solution {
+    pub fn maximum_length(nums: Vec<i32>, k: i32) -> i32 {
+        let k = k as usize;
+        let mut f = vec![vec![0; k]; k];
+        let mut ans = 0;
+        for x in nums {
+            let x = (x % k as i32) as usize;
+            for j in 0..k {
+                let y = (j + k - x) % k;
+                f[x][y] = f[y][x] + 1;
+                ans = ans.max(f[x][y]);
+            }
+        }
+        ans
+    }
+}

solution/3600-3699/3603.Minimum Cost Path with Alternating Directions II/README.md

@@ -24,13 +24,13 @@ tags:
 
 <p>另外给你一个二维整数数组 <code>waitCost</code>，其中 <code>waitCost[i][j]</code> 定义了在该单元格&nbsp;<strong>等待&nbsp;</strong>的成本。</p>
 
-<p>你从第 1 秒开始在单元格 <code>(0, 0)</code>。</p>
+<p>路径始终从第 1 步进入单元格 <code>(0, 0)</code>&nbsp;并支付入场花费开始。</p>
 
 <p>每一步，你都遵循交替模式：</p>
 
 <ul>
 	<li>在&nbsp;<strong>奇数秒&nbsp;</strong>，你必须向&nbsp;<strong>右&nbsp;</strong>或向&nbsp;<strong>下&nbsp;</strong>移动到&nbsp;<strong>相邻&nbsp;</strong>的单元格，并支付其进入成本。</li>
-	<li>在&nbsp;<strong>偶数秒&nbsp;</strong>，你必须原地&nbsp;<strong>等待&nbsp;</strong>，并支付 <code>waitCost[i][j]</code>。</li>
+	<li>在&nbsp;<strong>偶数秒&nbsp;</strong>，你必须原地&nbsp;<strong>等待</strong><strong>恰好</strong>&nbsp;1 秒并在 1 秒期间支付 <code>waitCost[i][j]</code>。</li>
 </ul>
 
 <p>返回到达 <code>(m - 1, n - 1)</code> 所需的&nbsp;<strong>最小&nbsp;</strong>总成本。</p>

solution/3600-3699/3603.Minimum Cost Path with Alternating Directions II/README_EN.md

@@ -24,13 +24,13 @@ tags:
 
 <p>You are also given a 2D integer array <code>waitCost</code> where <code>waitCost[i][j]</code> defines the cost to <strong>wait</strong> on that cell.</p>
 
-<p>You start at cell <code>(0, 0)</code> at second 1.</p>
+<p>The path will always begin by entering cell <code>(0, 0)</code> on move 1 and paying the entrance cost.</p>
 
 <p>At each step, you follow an alternating pattern:</p>
 
 <ul>
 	<li>On <strong>odd-numbered</strong> seconds, you must move <strong>right</strong> or <strong>down</strong> to an <strong>adjacent</strong> cell, paying its entry cost.</li>
-	<li>On <strong>even-numbered</strong> seconds, you must <strong>wait</strong> in place, paying <code>waitCost[i][j]</code>.</li>
+	<li>On <strong>even-numbered</strong> seconds, you must <strong>wait</strong> in place for <strong>exactly</strong> one second and pay <code>waitCost[i][j]</code> during that second.</li>
 </ul>
 
 <p>Return the <strong>minimum</strong> total cost required to reach <code>(m - 1, n - 1)</code>.</p>