feat: add solutions to lc problem: No.0494

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

@@ -2,16 +2,22 @@ class Solution {
 public:
     int findTargetSumWays(vector<int>& nums, int target) {
         int s = accumulate(nums.begin(), nums.end(), 0);
-        if (s < target || (s - target) % 2 != 0) return 0;
-        int m = nums.size(), n = (s - target) / 2;
-        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
-        dp[0][0] = 1;
+        if (s < target || (s - target) % 2) {
+            return 0;
+        }
+        int m = nums.size();
+        int n = (s - target) / 2;
+        int f[m + 1][n + 1];
+        memset(f, 0, sizeof(f));
+        f[0][0] = 1;
         for (int i = 1; i <= m; ++i) {
             for (int j = 0; j <= n; ++j) {
-                dp[i][j] += dp[i - 1][j];
-                if (nums[i - 1] <= j) dp[i][j] += dp[i - 1][j - nums[i - 1]];
+                f[i][j] = f[i - 1][j];
+                if (j >= nums[i - 1]) {
+                    f[i][j] += f[i - 1][j - nums[i - 1]];
+                }
             }
         }
-        return dp[m][n];
+        return f[m][n];
     }
 };

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

@@ -1,24 +1,24 @@
 func findTargetSumWays(nums []int, target int) int {
 	s := 0
-	for _, v := range nums {
-		s += v
+	for _, x := range nums {
+		s += x
 	}
 	if s < target || (s-target)%2 != 0 {
 		return 0
 	}
 	m, n := len(nums), (s-target)/2
-	dp := make([][]int, m+1)
-	for i := range dp {
-		dp[i] = make([]int, n+1)
+	f := make([][]int, m+1)
+	for i := range f {
+		f[i] = make([]int, n+1)
 	}
-	dp[0][0] = 1
+	f[0][0] = 1
 	for i := 1; i <= m; i++ {
 		for j := 0; j <= n; j++ {
-			dp[i][j] = dp[i-1][j]
-			if nums[i-1] <= j {
-				dp[i][j] += dp[i-1][j-nums[i-1]]
+			f[i][j] = f[i-1][j]
+			if j >= nums[i-1] {
+				f[i][j] += f[i-1][j-nums[i-1]]
 			}
 		}
 	}
-	return dp[m][n]
+	return f[m][n]
 }

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

@@ -1,24 +1,21 @@
 class Solution {
     public int findTargetSumWays(int[] nums, int target) {
-        int s = 0;
-        for (int v : nums) {
-            s += v;
-        }
+        int s = Arrays.stream(nums).sum();
         if (s < target || (s - target) % 2 != 0) {
             return 0;
         }
         int m = nums.length;
         int n = (s - target) / 2;
-        int[][] dp = new int[m + 1][n + 1];
-        dp[0][0] = 1;
+        int[][] f = new int[m + 1][n + 1];
+        f[0][0] = 1;
         for (int i = 1; i <= m; ++i) {
             for (int j = 0; j <= n; ++j) {
-                dp[i][j] = dp[i - 1][j];
-                if (nums[i - 1] <= j) {
-                    dp[i][j] += dp[i - 1][j - nums[i - 1]];
+                f[i][j] = f[i - 1][j];
+                if (j >= nums[i - 1]) {
+                    f[i][j] += f[i - 1][j - nums[i - 1]];
                 }
             }
         }
-        return dp[m][n];
+        return f[m][n];
     }
 }

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

@@ -4,21 +4,20 @@
  * @return {number}
  */
 var findTargetSumWays = function (nums, target) {
-    let s = 0;
-    for (let v of nums) {
-        s += v;
-    }
-    if (s < target || (s - target) % 2 != 0) {
+    const s = nums.reduce((a, b) => a + b, 0);
+    if (s < target || (s - target) % 2) {
         return 0;
     }
-    const m = nums.length;
-    const n = (s - target) / 2;
-    let dp = new Array(n + 1).fill(0);
-    dp[0] = 1;
-    for (let i = 1; i <= m; ++i) {
-        for (let j = n; j >= nums[i - 1]; --j) {
-            dp[j] += dp[j - nums[i - 1]];
+    const [m, n] = [nums.length, ((s - target) / 2) | 0];
+    const f = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    f[0][0] = 1;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 0; j <= n; j++) {
+            f[i][j] = f[i - 1][j];
+            if (j >= nums[i - 1]) {
+                f[i][j] += f[i - 1][j - nums[i - 1]];
+            }
         }
     }
-    return dp[n];
+    return f[m][n];
 };

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

@@ -1,14 +1,14 @@
 class Solution:
     def findTargetSumWays(self, nums: List[int], target: int) -> int:
         s = sum(nums)
-        if s < target or (s - target) % 2 != 0:
+        if s < target or (s - target) % 2:
             return 0
         m, n = len(nums), (s - target) // 2
-        dp = [[0] * (n + 1) for _ in range(m + 1)]
-        dp[0][0] = 1
-        for i in range(1, m + 1):
+        f = [[0] * (n + 1) for _ in range(m + 1)]
+        f[0][0] = 1
+        for i, x in enumerate(nums, 1):
             for j in range(n + 1):
-                dp[i][j] = dp[i - 1][j]
-                if nums[i - 1] <= j:
-                    dp[i][j] += dp[i - 1][j - nums[i - 1]]
-        return dp[-1][-1]
+                f[i][j] = f[i - 1][j]
+                if j >= x:
+                    f[i][j] += f[i - 1][j - x]
+        return f[m][n]

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

@@ -1,36 +1,21 @@
 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
+        let s: i32 = nums.iter().sum();
+        if s < target || (s - target) % 2 != 0 {
             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)];
+        let m = nums.len();
+        let n = ((s - target) / 2) as usize;
+        let mut f = vec![vec![0; n + 1]; m + 1];
+        f[0][0] = 1;
+        for i in 1..=m {
+            for j in 0..=n {
+                f[i][j] = f[i - 1][j];
+                if j as i32 >= nums[i - 1] {
+                    f[i][j] += f[i - 1][j - nums[i - 1] as usize];
                 }
             }
         }
-
-        dp[n][m as usize]
+        f[m][n]
     }
 }

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

@@ -0,0 +1,18 @@
+function findTargetSumWays(nums: number[], target: number): number {
+    const s = nums.reduce((a, b) => a + b, 0);
+    if (s < target || (s - target) % 2) {
+        return 0;
+    }
+    const [m, n] = [nums.length, ((s - target) / 2) | 0];
+    const f: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    f[0][0] = 1;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 0; j <= n; j++) {
+            f[i][j] = f[i - 1][j];
+            if (j >= nums[i - 1]) {
+                f[i][j] += f[i - 1][j - nums[i - 1]];
+            }
+        }
+    }
+    return f[m][n];
+}

solution/0400-0499/0494.Target Sum/Solution2.cpp

@@ -2,13 +2,18 @@ class Solution {
 public:
     int findTargetSumWays(vector<int>& nums, int target) {
         int s = accumulate(nums.begin(), nums.end(), 0);
-        if (s < target || (s - target) % 2 != 0) return 0;
+        if (s < target || (s - target) % 2) {
+            return 0;
+        }
         int n = (s - target) / 2;
-        vector<int> dp(n + 1);
-        dp[0] = 1;
-        for (int& v : nums)
-            for (int j = n; j >= v; --j)
-                dp[j] += dp[j - v];
-        return dp[n];
+        int f[n + 1];
+        memset(f, 0, sizeof(f));
+        f[0] = 1;
+        for (int x : nums) {
+            for (int j = n; j >= x; --j) {
+                f[j] += f[j - x];
+            }
+        }
+        return f[n];
     }
 };

solution/0400-0499/0494.Target Sum/Solution2.go

@@ -1,18 +1,18 @@
 func findTargetSumWays(nums []int, target int) int {
 	s := 0
-	for _, v := range nums {
-		s += v
+	for _, x := range nums {
+		s += x
 	}
 	if s < target || (s-target)%2 != 0 {
 		return 0
 	}
 	n := (s - target) / 2
-	dp := make([]int, n+1)
-	dp[0] = 1
-	for _, v := range nums {
-		for j := n; j >= v; j-- {
-			dp[j] += dp[j-v]
+	f := make([]int, n+1)
+	f[0] = 1
+	for _, x := range nums {
+		for j := n; j >= x; j-- {
+			f[j] += f[j-x]
 		}
 	}
-	return dp[n]
+	return f[n]
 }

solution/0400-0499/0494.Target Sum/Solution2.java

@@ -1,20 +1,17 @@
 class Solution {
     public int findTargetSumWays(int[] nums, int target) {
-        int s = 0;
-        for (int v : nums) {
-            s += v;
-        }
+        int s = Arrays.stream(nums).sum();
         if (s < target || (s - target) % 2 != 0) {
             return 0;
         }
         int n = (s - target) / 2;
-        int[] dp = new int[n + 1];
-        dp[0] = 1;
-        for (int v : nums) {
-            for (int j = n; j >= v; --j) {
-                dp[j] += dp[j - v];
+        int[] f = new int[n + 1];
+        f[0] = 1;
+        for (int num : nums) {
+            for (int j = n; j >= num; --j) {
+                f[j] += f[j - num];
             }
         }
-        return dp[n];
+        return f[n];
     }
 }

solution/0400-0499/0494.Target Sum/Solution2.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var findTargetSumWays = function (nums, target) {
+    const s = nums.reduce((a, b) => a + b, 0);
+    if (s < target || (s - target) % 2) {
+        return 0;
+    }
+    const n = (s - target) / 2;
+    const f = Array(n + 1).fill(0);
+    f[0] = 1;
+    for (const x of nums) {
+        for (let j = n; j >= x; j--) {
+            f[j] += f[j - x];
+        }
+    }
+    return f[n];
+};

solution/0400-0499/0494.Target Sum/Solution2.py

@@ -1,12 +1,12 @@
 class Solution:
     def findTargetSumWays(self, nums: List[int], target: int) -> int:
         s = sum(nums)
-        if s < target or (s - target) % 2 != 0:
+        if s < target or (s - target) % 2:
             return 0
         n = (s - target) // 2
-        dp = [0] * (n + 1)
-        dp[0] = 1
-        for v in nums:
-            for j in range(n, v - 1, -1):
-                dp[j] += dp[j - v]
-        return dp[-1]
+        f = [0] * (n + 1)
+        f[0] = 1
+        for x in nums:
+            for j in range(n, x - 1, -1):
+                f[j] += f[j - x]
+        return f[n]

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

@@ -1,29 +1,17 @@
 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
+        let s: i32 = nums.iter().sum();
+        if s < target || (s - target) % 2 != 0 {
             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)];
+        let n = ((s - target) / 2) as usize;
+        let mut f = vec![0; n + 1];
+        f[0] = 1;
+        for x in nums {
+            for j in (x as usize..=n).rev() {
+                f[j] += f[j - x as usize];
             }
         }
-
-        dp[n]
+        f[n]
     }
 }