feat: add rust solution to lc problem: No.0494 (#1227)

Author: xzhseh

solution/0400-0499/0494.Target Sum/README.md

@@ -211,6 +211,79 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn find_target_sum_ways(nums: Vec<i32>, target: i32) -> i32 {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        // -x + (sum - x) = target <-> -2 * x + sum = target <-> 2 * x = sum - target
+        if sum < target || (sum - target) % 2 != 0 {
+            // There is no way to get any expression in this case
+            return 0;
+        }
+        let n = nums.len();
+        let m = (sum - target) / 2;
+
+        let mut dp: Vec<Vec<i32>> = vec![vec![0; m as usize + 1]; n + 1];
+
+        // Initialize the dp vector
+        dp[0][0] = 1;
+
+        // Begin the actual dp phase
+        for i in 1..=n {
+            for j in 0..=m as usize {
+                // nums[i - 1] is not included
+                dp[i][j] = dp[i - 1][j];
+                if nums[i - 1] <= j as i32 {
+                    // nums[i - 1] is included
+                    dp[i][j] += dp[i - 1][j - nums[i - 1] as usize];
+                }
+            }
+        }
+
+        dp[n][m as usize]
+    }
+}
+```
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn find_target_sum_ways(nums: Vec<i32>, target: i32) -> i32 {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        if sum < target || (sum - target) % 2 != 0 {
+            // Just directly return
+            return 0;
+        }
+
+        let n = ((sum - target) / 2) as usize;
+        let mut dp: Vec<i32> = vec![0; n + 1];
+
+        // Initialize the dp vector
+        dp[0] = 1;
+
+        // Begin the actual dp phase
+        for e in &nums {
+            for i in (*e as usize..=n).rev() {
+                dp[i] += dp[i - *e as usize];
+            }
+        }
+
+        dp[n]
+    }
+}
+```
+
 ### **Go**
 
 ```go

solution/0400-0499/0494.Target Sum/README_EN.md

@@ -195,6 +195,79 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn find_target_sum_ways(nums: Vec<i32>, target: i32) -> i32 {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        // -x + (sum - x) = target <-> -2 * x + sum = target <-> 2 * x = sum - target
+        if sum < target || (sum - target) % 2 != 0 {
+            // There is no way to get any expression in this case
+            return 0;
+        }
+        let n = nums.len();
+        let m = (sum - target) / 2;
+
+        let mut dp: Vec<Vec<i32>> = vec![vec![0; m as usize + 1]; n + 1];
+
+        // Initialize the dp vector
+        dp[0][0] = 1;
+
+        // Begin the actual dp phase
+        for i in 1..=n {
+            for j in 0..=m as usize {
+                // nums[i - 1] is not included
+                dp[i][j] = dp[i - 1][j];
+                if nums[i - 1] <= j as i32 {
+                    // nums[i - 1] is included
+                    dp[i][j] += dp[i - 1][j - nums[i - 1] as usize];
+                }
+            }
+        }
+
+        dp[n][m as usize]
+    }
+}
+```
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn find_target_sum_ways(nums: Vec<i32>, target: i32) -> i32 {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        if sum < target || (sum - target) % 2 != 0 {
+            // Just directly return
+            return 0;
+        }
+
+        let n = ((sum - target) / 2) as usize;
+        let mut dp: Vec<i32> = vec![0; n + 1];
+
+        // Initialize the dp vector
+        dp[0] = 1;
+
+        // Begin the actual dp phase
+        for e in &nums {
+            for i in (*e as usize..=n).rev() {
+                dp[i] += dp[i - *e as usize];
+            }
+        }
+
+        dp[n]
+    }
+}
+```
+
 ### **Go**
 
 ```go

solution/0400-0499/0494.Target Sum/Solution.rs

@@ -0,0 +1,36 @@
+impl Solution {
+    #[allow(dead_code)]
+    pub fn find_target_sum_ways(nums: Vec<i32>, target: i32) -> i32 {
+        let mut sum = 0;
+        for e in &nums {
+            sum += *e;
+        }
+
+        // -x + (sum - x) = target <-> -2 * x + sum = target <-> 2 * x = sum - target
+        if sum < target || (sum - target) % 2 != 0 {
+            // There is no way to get any expression in this case
+            return 0;
+        }
+        let n = nums.len();
+        let m = (sum - target) / 2;
+
+        let mut dp: Vec<Vec<i32>> = vec![vec![0; m as usize + 1]; n + 1];
+
+        // Initialize the dp vector
+        dp[0][0] = 1;
+
+        // Begin the actual dp phase
+        for i in 1..=n {
+            for j in 0..=m as usize {
+                // nums[i - 1] is not included
+                dp[i][j] = dp[i - 1][j];
+                if nums[i - 1] <= j as i32 {
+                    // nums[i - 1] is included
+                    dp[i][j] += dp[i - 1][j - nums[i - 1] as usize];
+                }
+            }
+        }
+
+        dp[n][m as usize]
+    }
+}