Day 42 | 0-1 Backpack Basic Theory（一）| 0-1 Backpack Basic Theory（二）| 416. Partition Equal Subset Sum-CSDN博客

本文链接：https://blog.csdn.net/kyle313606922/article/details/130127811

0-1 Backpack Basic Theory（一）

Determine the meaning of dp[i][j]
- dp[i][j] is the maximum value of items that are taken from subscript 0 to i and put into the backpack with capacity j
Determine the recursive formula
- Doesn’t contain item i: dp[i][j] is dp[i-1][j]. The item i can’t be put into the backpack when the weight of item i is greater than the backpack j weight. So the value of items in the backpack remains the same as before.
- Contain item i: dp[i - 1][j - weight[i]] is the maximum value when the capacity of backpack is j - weight[i] and doesn’t contain the item i. value[i] is the value of item i. So dp[i-1][j-weight[i]] + value[i] is the maximum value when containing the item i.
- So the recursive formula is: dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
Initialize the dynamic programming array
- If the capacity of backpack is 0, like dp[i][0]. No matter which items are selected, the total value must be 0.
- When j < weight[0], dp[0][j] should be 0.
- When j >= weight[0], dp[0][j] should be value[0]
- According to the recursive formula, dp[i][j] is derived from the upper left value. So the other subscripts can be initialized to whatever values, because they will be overwritten. It’s more convenient to initialize the dynamic programming array to 0.
Traversal order
- Actually, traversing item first and traversing backpack capacity first all work. The traversing item first is better understood.

// The size of the weight array is the number of items
for(int i = 1; i < weight.size(); i++) { // Traverse items
    for(int j = 0; j <= bagweight; j++) { // Traverse backpack capacity
        if (j < weight[i]) dp[i][j] = dp[i - 1][j];
        else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
    }

0-1 Backpack Basic Theory（二）

Determine the meaning of dp[j]
- dp[j] is the maximum value of items carried in the backpack with capacity j
Determine the recursive formula
- Doesn’t contain item i: dp[j] is dp[i-1][j]. The item i can’t be put into the backpack when the weight of item i is greater than the backpack j weight. So the value of items in the backpack remains the same as before.
- Contain item i: dp[j - weight[i]] denotes the maximum value of items carried by a backpack with capacity j - weight[i] and doesn’t contain the item i. value[i] is the value of item i. So dp[j-weight[i]] + value[i] is the maximum value when containing the item i.
- So the recursive formula is: dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
Initialize the dynamic programming array
- If the capacity of backpack is 0, like dp[0]. No matter which items are selected, the total value must be 0.
- The dynamic programming array must be derived by taking the number with the largest value. We can initialize the array to 0. In this way, the dp array will get the maximum value when doing the recursion instead of being overwritten by initial value.
Traversal order
- The order of traversing the backpack is different. For 2D dp traversal, the backpack capacity is from small to large, while for 1D dp traversal, the backpack is from large to small. The reverse order traversal is to ensure that item i is only put in once, cause the positive order traversal will lead to item 0 be repeatedly added multiple times.
- Why don’t we use reverse order for the two-dimensional dp array? Because for two-dimensional dp, dp[i][j] are computed through the previous layerdp[i-1][j]. So the dp[i][j] of this layer won’t be overwritten.
- For the order of the two nested for loops. We must adopt traversing item first instead of traversing backpack capacity first. Because if we adopt traversing backpack capacity first, then only one item will be put in each dp[j](backpack).
- The one-dimensional array traversal is still essentially a traversal of a two-dimensional array. The value in the lower right corner depends on the value in the upper left corner of the previous layer. So we need to ensure the left value is still from the previous layer, overwritten from right to the left.

for(int i = 0; i < weight.size(); i++) { 			// Traversing items
    for(int j = bagWeight; j >= weight[i]; j--) { // Traversing backpack capacity
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

416. Partition Equal Subset Sum

link

class Solution {
    public boolean canPartition(int[] nums) {
        if(nums==null || nums.length==0) return false;
        int sum = 0;
        for(int num : nums)
            sum += num;
        // if sum is odd number, two subsets can not be equal
        if(sum%2 != 0) return false;
        int target = sum / 2;
        int[] dp = new int[target + 1];
        for(int i = 0; i < nums.length; i++){       // Traversing items
            for(int j = target; j >= nums[i]; j--)  // Traversing capacity
                dp[j] = Math.max(dp[j], dp[j-nums[i]] + nums[i]);
        }
        return dp[target] == target;
    }
}