update dp 4

Author: geemaple

lintcode/562.backpack-iv.cpp

@@ -45,21 +45,19 @@ class Solution {
     int backPackIV(vector<int> &nums, int target) {
         // write your code here
         int n = nums.size();
-        int m = target;
-        vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
+        vector<vector<int>> dp(n + 1, vector<int>(target + 1, 0));
         dp[0][0] = 1;
         for (int i = 1; i <= n; i++) {
-            for (int j = 0; j <= m; j++) {
-                int w = nums[i - 1];
-                if (w <= j) {
-                    dp[i][j] = dp[i - 1][j] + dp[i][j - w];
-                } else {
-                    dp[i][j] = dp[i - 1][j];
+            for (int j = 0; j <= target; j++) {
+                int weight = nums[i - 1];
+                dp[i][j] = dp[i - 1][j];
+                if (j >= weight) {
+                    dp[i][j] += dp[i][j - weight];
                 }
             }
         }
 
-        return dp[n][m];
+        return dp[n][target];
     }
 };
 
@@ -73,18 +71,17 @@ class Solution {
     int backPackIV(vector<int> &nums, int target) {
         // write your code here
         int n = nums.size();
-        int m = target;
-        vector<int> dp(m + 1, 0);
+        vector<int> dp(target + 1, 0);
         dp[0] = 1;
         for (int i = 1; i <= n; i++) {
-            for (int j = 0; j <= m; j++) {
-                int w = nums[i - 1];
-                if (w <= j) {
-                    dp[j] = dp[j] + dp[j - w];
-                }
+            for (int j = 0; j <= target; j++) {
+                int weight = nums[i - 1];
+                if (j >= weight) {
+                    dp[j] += dp[j - weight];
+                } 
             }
         }
 
-        return dp[m];
+        return dp[target];
     }
 };

lintcode/562.backpack-iv.py

@@ -48,18 +48,19 @@ class Solution:
     def back_pack_i_v(self, nums: List[int], target: int) -> int:
         # write your code here
         n = len(nums)
-        m = target
-        dp = [[0 for j in range(m + 1)] for i in range(n + 1)]
-        dp[0][0] = 1
+        dp = [[0] * (target + 1) for i in range(n + 1)]
+
+        for i in range(n + 1):
+            dp[i][0] = 1
+
         for i in range(1, n + 1):
-            for j in range(m + 1):
-                w = nums[i - 1]
-                if w <= j:
-                    dp[i][j] = dp[i - 1][j] + dp[i][j - w]
-                else:
-                    dp[i][j] = dp[i - 1][j]
+            for j in range(1, target + 1):
+                dp[i][j] = dp[i - 1][j]
+                weight = nums[i - 1]
+                if j >= weight:
+                    dp[i][j] += dp[i][j - weight]
 
-        return dp[n][m]
+        return dp[n][target]
 
 class Solution:
     """
@@ -70,13 +71,13 @@ class Solution:
     def back_pack_i_v(self, nums: List[int], target: int) -> int:
         # write your code here
         n = len(nums)
-        m = target
-        dp = [0 for j in range(m + 1)]
+        dp = [0 for i in range(target + 1)]
         dp[0] = 1
+
         for i in range(1, n + 1):
-            for j in range(m + 1):
-                w = nums[i - 1]
-                if w <= j:
-                    dp[j] = dp[j] + dp[j - w]
+            for j in range(1, target + 1):
+                weight = nums[i - 1]
+                if j >= weight:
+                    dp[j] += dp[j - weight]
 
-        return dp[m]
+        return dp[target]

test/python.py

@@ -8,34 +8,30 @@
     List,
 )
 
-from typing import (
-    List,
-)
-
 class Solution:
     """
-    @param nums: an integer array and all positive numbers
+    @param nums: an integer array and all positive numbers, no duplicates
     @param target: An integer
     @return: An integer
     """
-    def back_pack_v(self, nums: List[int], target: int) -> int:
+    def back_pack_i_v(self, nums: List[int], target: int) -> int:
         # write your code here
         n = len(nums)
-        dp = [0] * (target + 1)
-        dp[0] = 1
+        dp = [[0] * (target + 1) for i in range(n + 1)]
+
+        for i in range(n + 1):
+            dp[i][0] = 1
 
         for i in range(1, n + 1):
-            tmp = list(dp)
             for j in range(1, target + 1):
+                dp[i][j] = dp[i - 1][j]
                 weight = nums[i - 1]
                 if j >= weight:
-                    tmp[j] = dp[j] + dp[j - weight]
-
-            dp = tmp
-        return dp[target]
+                    dp[i][j] += dp[i][j - weight]
 
+        return dp[n][target]
 
 
 s = Solution()
-res = s.back_pack_v([1,2,3,3,7], 7)
+res = s.back_pack_i_v([2,3,4,5], 7)
 print(res)