动态规划0-1背包问题滚动数组

1、经典0-1背包问题

问题描述：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内选择物品使得物品的总价值最高。
回顾对于二维的0-1背包问题递推关系式：
$$dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i])$$
$dp[i][j]$表示的是从0到i标号的物品中放入承重为j的背包中最大的价值总和。
首先，对于此公式的解释：每次选择只有两种情况，在物品$0,1,...,i$中不选择和选择物品$i$。对于边界初始化：$$dp[0][0]=dp[i][0]=0,dp[0][j]=value[j]$$其他数组中的值全部置为0，这是因为每次更新都取最大值，且所以这些值都会被覆盖，所以初始化全0是没问题的。同时，遍历次序物品先还是背包先，顺序还是逆序都是可以得到正确结果的。

2、滚动数组

回顾我们在做斐波那契数列的时候，空间复杂度可以从O(N)降到O(1)(用两个位置去储存即可），这也是滚动数组的基本思想，做空间压缩。
从上面的递推关系我们可以发现，$dp[i][j]$只和第一维为$i-1$的dp数组有关，所以可以将递推公式中的$i-1$替换为$i$，将第$i-1$层的结果写入$i$层中，即$$dp[i][j]=max(dp[i][j],dp[i][j-weight[i]+value[i])$$这说明第一个维度只用存储一个数据，这就是可以二维压缩到一维的原因。$dp[j]$表示的是容量大小为$j$的背包能达到的最大价值和。对比二维的递推表达，我们有如下一维递推：$$dp[j]=max(dp[j],dp[j-weight[i]]+value[i])$$不放物品$i$为$dp[j]$，这是因为$dp[i][j]=dp[i-1][j]$只是将上一层的结果进行了拷贝；放了物品$i$的结果和二维的类似可得。初始化，根据一维$dp$数组的含义，显然$dp[0]=0$，同样这里的$dp[i]$可以置为0。关于遍历次序的理解，这里以一个例子来说明：假设有标号0，1，2的三个物品weight分别为1，3，4；value分别为15，20，30。遍历的顺序这里采用的是先遍历物品再逆序遍历背包。首先说明这样遍历的可行性。

 for i in range(3):
     for j in range(4, weight[i] - 1, -1):
         dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

注意到$$\begin{gathered} i=0,j=4,dp[4]=value[0]=15=dp[0][4] \\ i=0,j=3,dp[3]=value[0]=15=dp[0][3] \\ ... \\ i=1,j=4,dp[4]=max(value[1]+dp[4-weight[1]],dp[4])=35=dp[1][4] \\ .. \end{gathered}$$
最后得到的每个$dp[j]=dp[2][j]$。而如果将背包承重遍历改变为顺序：

$$\begin{gathered} i=0,j=0,dp[0]=0=dp[0][0] \\ i=0,j=1,dp[1]=value[0]=15=dp[0][1] \\ i=0,j=2,dp[2]=max(dp[1]+value[0],dp[2])=15+15=30\ne dp[0][2]=15 \\ ... \end{gathered}$$
可以看到$dp[2]$的结果显然是不对的,物品0被放入了两次。这是因为计算dp[2]的时候又用到了更新之后的dp[1]。可以对照二维dp的情况，i=0的情况都进行了初始化且没有相互影响。说的更明白一点，比如$i=1,dp[3]$的结果会用到$dp[2]=dp[0][2]$，而$dp[2]$在此之前已经更新为$dp[1][2]$，这样计算的$dp[3]$肯定不对了。同理，交换物品和背包承重的循环顺序仍然会计算错误。这一块最好还是实际画一遍dp数组遍历过程才会更清楚。
下面以一个实际的例子来看。

3、实例

力扣分隔等和子集： 给你一个只包含正整数的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
https://leetcode.cn/problems/partition-equal-subset-sum/

1、问题分析：从数组中选出若干数字，使得数字总价值为sum/2。对比01背包问题，nums的元素相当于物品重量，sum相等于背包承重。
2、设置dp数组和下标含义：$d[i][j]$表示否存在从下标$[0,i]$中选取元素，使得和为恰好为$j$的情况，存在则返回True。
3、递推关系式：
A、不选下标为i的元素：$$dp[i][j]=dp[i-1][j]$$
B、选择下标为i的元素，因为数组中元素都是正整数，其中还要分两类来看：1）如果$nums[i]==j$， $$dp[i][j]=True$$
2）如果$nums[i]<j$，$$dp[i][j]=dp[i-1][j-nums[i]]$$
3）如果$nums[i]>j$，归为第一类情况。
4、初始化：$dp[0][0]=False$

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        # 判断特殊条件
        sum1 = sum(nums)
        if sum1%2 != 0 or len(nums) < 2 or sum1 < 2 * max(nums):
            return False
        sum1 = sum1 // 2
        n = len(nums)
        # 初始化dp
        dp = [[False for x in range(sum1+1)] for x in range(n)]
        dp[0][nums[0]] = True
        # 递推：
        for i in range(1,n):
            for j in range(1,sum1+1):
                if nums[i] == j:
                    dp[i][j] = True
                elif nums[i] < j:
                    dp[i][j] = dp[i-1][j-nums[i]] or dp[i-1][j]
                else:
                    dp[i][j] = dp[i-1][j]   
        return dp[n-1][sum1]

注意到这个问题中，$dp[i]$层的结果只和$dp[i-1]$的相关，所以依然可以压缩为一维dp数组。

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        # 判断特殊条件
        sum1 = sum(nums)
        if sum1%2 != 0 or len(nums) < 2 or sum1 < 2 * max(nums):
            return False
        sum1 = sum1 // 2
        n = len(nums)
        dp = [False for x in range(sum1+1)]
        for i in range(1,n):
            for j in range(sum1,0,-1):
                if nums[i] == j:
                    dp[j] = True
                elif nums[i] < j:
                    dp[j] = dp[j-nums[i]] or dp[j]
                else:
                    dp[j] = dp[j]   
        return dp[sum1]