动态规划01背包之416分割等和子集

题目：

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例：

题目链接：416. 分割等和子集 - 力扣（LeetCode）

解法：

先复习一下01背包问题：

dp[i][j]的含义：从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

那么可以有两个方向推出来dp[i][j]：

不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以背包内的价值依然和前面相同。)

放物品i：由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值。

所以递归公式：  ;

只有确定了如下四点，才能把01背包问题套到本题上来。

（1）背包的最大体积为bagweight=sum / 2，背包可放入的商品个数为n = nums.size()。

（2）背包要放入的商品（集合里的元素）体积为 元素的数值，价值也为元素的数值。

（3）背包如果正好装满，说明找到了总和为 sum / 2 的子集。

（4）背包中每一个元素是不可重复放入。

二维dp法：

class Solution {
public:
    bool canPartition(vector<int>& nums) 
    {
        /**
        1. dp数组含义：dp[i][j]为背包重量为j时，从[0到i]元素和最大值
        2. 递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i])
        3. 初始化： （1）dp[i][0]初始化为0。因为背包重量为0时，不可能放入元素。
                   （2）dp[0][j] = nums[0]，当j >= nums[0] && j < bagWeight时
        4. 遍历顺序：先遍历物品，再遍历背包
        */
        int n=nums.size();//背包的物品个数
        /* nums大小判断 */
        if(n < 2) return false;
        int sum=0;
        int bagWeight = 0;
        for(int i=0;i<n;i++)
        {
            sum += nums[i];
        }
        if(sum % 2 == 1) return false;//数组和是奇数
        bagWeight=sum/2;//背包容量
        vector<vector<int>> dp(n,vector<int>(bagWight+1,0));
        //初始化
        //（1）背包重量为0时，不可能放入元素
        for (int i = 0 ; i < nums.size(); i++) 
        {  // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点。
            dp[i][0] = 0;
        }
        for (int j = nums[0]; j <= bagWeight; j++) 
        {
            dp[0][j] = nums[0];
        }

        for(int i=1;i<n;i++)
        {
            for(int j=0;j<=bagWeight;j++)
            {
                if (j <nums[i]) dp[i][j] = dp[i - 1][j];
                else dp[i][j]=max(dp[i - 1][j],dp[i-1][j-nums[i]]+nums[i]);
            }
        }

        if (dp[n-1][bagWeight] == bagWeight) return true;  
        return false;

    }
};

一维dp法：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;

        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        int bagweight = sum / 2;//背包重量为bagweight
        vector<int> dp(bagweight+1, 0);//初始化：从0到bagweight个行
        // 也可以使用库函数一步求和
        // int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2 == 1) return false;

        // 开始 01背包
        for(int i = 0; i < nums.size(); i++) 
        {
            for(int j = bagweight; j >= nums[i]; j--) 
            { // 每一个元素一定是不可重复放入，所以从大到小遍历
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        // 集合中的元素正好可以凑成总和bagweight
        if (dp[bagweight] == bagweight) return true;
        return false;
    }
};