feat: add rust solution to lc problem: No.0416 (doocs#1229)

Author: xzhseh

solution/0400-0499/0416.Partition Equal Subset Sum/README.md

@@ -192,6 +192,80 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_partition(nums: Vec<i32>) -> bool {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        if sum % 2 != 0 {
+            return false;
+        }
+
+        let n = nums.len();
+        let m = (sum / 2) as usize;
+        let mut dp: Vec<Vec<bool>> = vec![vec![false; m + 1]; n + 1];
+
+        // Initialize the dp vector
+        dp[0][0] = true;
+
+        // Begin the actual dp process
+        for i in 1..=n {
+            for j in 0..=m {
+                dp[i][j] = if nums[i - 1] as usize > j {
+                    dp[i - 1][j]
+                } else {
+                    dp[i - 1][j] || dp[i - 1][j - nums[i - 1] as usize]
+                }
+            }
+        }
+
+        dp[n][m]
+    }
+}
+```
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_partition(nums: Vec<i32>) -> bool {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        if sum % 2 != 0 {
+            return false;
+        }
+
+        let m = (sum >> 1) as usize;
+
+        // Here dp[i] means if it can be sum up to `i` for all the number we've traversed through so far
+        // Which is actually compressing the 2-D dp vector to 1-D
+        let mut dp: Vec<bool> = vec![false; m + 1];
+
+        // Initialize the dp vector
+        dp[0] = true;
+
+        // Begin the actual dp process
+        for e in &nums {
+            // For every num in nums vector
+            for i in (*e as usize..=m).rev() {
+                // Update the current status
+                dp[i] |= dp[i - *e as usize];
+            }
+        }
+
+        dp[m]
+    }
+}
+```
+
 ### **Go**
 
 ```go

solution/0400-0499/0416.Partition Equal Subset Sum/README_EN.md

@@ -165,6 +165,80 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_partition(nums: Vec<i32>) -> bool {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        if sum % 2 != 0 {
+            return false;
+        }
+
+        let n = nums.len();
+        let m = (sum / 2) as usize;
+        let mut dp: Vec<Vec<bool>> = vec![vec![false; m + 1]; n + 1];
+
+        // Initialize the dp vector
+        dp[0][0] = true;
+
+        // Begin the actual dp process
+        for i in 1..=n {
+            for j in 0..=m {
+                dp[i][j] = if nums[i - 1] as usize > j {
+                    dp[i - 1][j]
+                } else {
+                    dp[i - 1][j] || dp[i - 1][j - nums[i - 1] as usize]
+                }
+            }
+        }
+
+        dp[n][m]
+    }
+}
+```
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_partition(nums: Vec<i32>) -> bool {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        if sum % 2 != 0 {
+            return false;
+        }
+
+        let m = (sum >> 1) as usize;
+
+        // Here dp[i] means if it can be sum up to `i` for all the number we've traversed through so far
+        // Which is actually compressing the 2-D dp vector to 1-D
+        let mut dp: Vec<bool> = vec![false; m + 1];
+
+        // Initialize the dp vector
+        dp[0] = true;
+
+        // Begin the actual dp process
+        for e in &nums {
+            // For every num in nums vector
+            for i in (*e as usize..=m).rev() {
+                // Update the current status
+                dp[i] |= dp[i - *e as usize];
+            }
+        }
+
+        dp[m]
+    }
+}
+```
+
 ### **Go**
 
 ```go

solution/0400-0499/0416.Partition Equal Subset Sum/Solution.rs

@@ -0,0 +1,33 @@
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_partition(nums: Vec<i32>) -> bool {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        if sum % 2 != 0 {
+            return false;
+        }
+
+        let n = nums.len();
+        let m = (sum / 2) as usize;
+        let mut dp: Vec<Vec<bool>> = vec![vec![false; m + 1]; n + 1];
+
+        // Initialize the dp vector
+        dp[0][0] = true;
+
+        // Begin the actual dp process
+        for i in 1..=n {
+            for j in 0..=m {
+                dp[i][j] = if nums[i - 1] as usize > j {
+                    dp[i - 1][j]
+                } else {
+                    dp[i - 1][j] || dp[i - 1][j - nums[i - 1] as usize]
+                }
+            }
+        }
+
+        dp[n][m]
+    }
+}