34天 动态规划3

416. 分割等和子集

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

注意: 每个数组中的元素不会超过 100 数组的大小不会超过 200

示例 1:

输入: [1, 5, 11, 5]
输出: true
解释: 数组可以分割成 [1, 5, 5] 和 [11].
示例 2:

输入: [1, 2, 3, 5]
输出: false
解释: 数组不能分割成两个元素和相等的子集.
提示：

1 <= nums.length <= 200
1 <= nums[i] <= 100

• 可以用背包思想，如果能找到一半的值正好放入背包内，那么就是可以的。

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

背包的体积为sum / 2
背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
背包如果正好装满，说明找到了总和为 sum / 2 的子集。
背包中每一个元素是不可重复放入。
以上分析完，我们就可以套用01背包，来解决这个问题了。

动规五部曲分析如下：

确定dp数组以及下标的含义
01背包中，dp[j] 表示： 容量为j的背包，所背的物品价值最大可以为dp[j]。

本题中每一个元素的数值既是重量，也是价值。

套到本题，dp[j]表示 背包总容量（所能装的总重量）是j，放进物品后，背的最大重量为dp[j]。

那么如果背包容量为target， dp[target]就是装满 背包之后的重量，所以 当 dp[target] == target 的时候，背包就装满了。

有友可能想，那还有装不满的时候？

拿输入数组 [1, 5, 11, 5]，举例， dp[7] 只能等于 6，因为 只能放进 1 和 5。

而dp[6] 就可以等于6了，放进1 和 5，那么dp[6] == 6，说明背包装满了。

确定递推公式

01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

本题，相当于背包里放入数值，那么物品i的重量是nums[i]，其价值也是nums[i]。

所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);

dp数组如何初始化
在01背包，一维dp如何初始化，已经讲过，

从dp[j]的定义来看，首先dp[0]一定是0。

如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。

可以这么理解背包问题，实际核心就是对于一件物体背还是不背，然后一件一件尝试将可以放进背包的物品放入，计算得到的val值会不会比以前大，会的话就放入，不会就拿出来试下一件物品

还有一个思考的点，dp初始化的大小是10001，其实target远没有这个大，设了很多空值，实际target+1就够了。

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

        // dp[i]中的i表示背包内总和
        // 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
        // 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
        vector<int> dp(10001, 0);
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        // 也可以使用库函数一步求和
        // int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2 == 1) return false;
        int target = sum / 2;

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

/*
class Solution {
public:
    bool canPartition(vector<int>& nums) {
        //dp数组意义 dp[i][j] i是物品，j是空间
        //int value[i]=nums[i];
        
        int sum=0;
        for(int a:nums){
            sum+=a;
        }
        if (sum % 2 != 0) {
            return false;
        }
        int bagweigths=sum/2; //bagweigths是书包的最大承重量
        vector<vector<int>> dp(nums.size(),vector<int>(bagweigths+1,0)); //nums.size()不加一是因为第一行不是没有物品，bagweigths+1意思是加了第一列，表示书包容量为空，加的目的是为了代表后边把空间沾满的剩余容量。
        //递推公式
        //dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i])
        //初始化方向
        for(int j=nums[0];j<=bagweigths;j++){
            dp[0][j]=nums[0];
        }
        for(int i=1;i<nums.size();i++){ //要对所有物品进行遍历，看要不要装进去
            for(int j=0;j<=bagweigths;j++){ //如果在背包范围内，就可以考虑。
                if(nums[i]>j) 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[nums.size()-1][bagweigths] == bagweigths) return true;
        return false;
    }
};*/

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        //dp数组意义 dp[i][j] i是物品，j是空间
        //int value[i]=nums[i];
        
        int sum=0;
        for(int a:nums){
            sum+=a;
        }
        if (sum % 2 != 0) {
            return false;
        }
        int bagweigths=sum/2; //bagweigths是书包的最大承重量
        vector<int> dp(bagweigths+1,0); //nums.size()不加一是因为第一行不是没有物品，bagweigths+1意思是加了第一列，表示书包容量为空，加的目的是为了代表后边把空间沾满的剩余容量。
        //递推公式
        //dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i])
        //初始化方向
        dp[0][0]=0;

        for(int i=1;i<nums.size();i++){ //要对所有物品进行遍历，看要不要装进去
            for(int j=bagweigths;j>= nums[i];j--){ //如果在背包范围内，就可以考虑。
            
                    dp[i][j]=max(dp[i-1][j],dp[i-1][j-nums[i]]+nums[i]);
            }
        }
        if (dp[nums.size()-1][bagweigths] == bagweigths) return true;
        return false;
    }
};

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
    //递推公式意义
    //dp[i][j] 该背包中最多有m个0和n个1组合的子集
    //递推公式：dp[i][j]=max(dp[i][j],dp[i-weigth[i]][j-weigth[j]]+dp[value[i][j]])
    //初始化
    vector<vector<int>> dp(m+1,vector<int>(n+1,0));
    //遍历方式
    for(string str :strs){//遍历物品
        int zero=0,one=0;//记录每件物品的重量
        for(char s:str){
            s=='0'? zero++:one++;
        }
        for(int i=m;i>=zero;i--){ //遍历背包，
            for(int j=n;j>=one;j--){
                dp[i][j]=max(dp[i][j],dp[i-zero][j-one]+1);
            }
        }
    }
    return dp[m][n];
    }
};

总结：
01背包两个递推公式：
排列组合：d[j]+=d[j-nums[i]] 初始化：d[0]=1,因为是0的话1后边都是0；
求最大价值：d[j]=max(d[j],d[j-weight[i]]+value[i]); 先遍历物品，再遍历背包，物品从0开始，背包倒序。
for(int i = 0; i < nums.size(); i++) { //起始值i为0，因为不用考率i-1越界。
for(int j = target; j >= nums[i]; j–) { // 每一个元素一定是不可重复放入，所以从大到小遍历
dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
}
}