2021-08-18 01背包应用

01背包应用

1.分割等和子集

dp[j]表示 背包总容量是j，最大可以凑成j的子集总和为dp[j]。

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

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

如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j，

bool canPartition(vector<int>& nums){
        int sum=0;
        vector<int> dp(10001,0);
        for(int i=0;i<nums.size();i++){//计算总和 
            sum+=nums[i];
        } 
        if(sum%2==1){//总和不是偶数则直接返回0 
            return 0;
        }
        int target=sum/2;
        for(int i=0;i<nums.size();i++){//套用01背包 
            for(int j=target;j>=nums[i];j--){
                dp[j]=max(dp[j],dp[j-nums[i]]+nums[i]);
                if(dp[j]==target){//证明该大小背包完全被利用
                    return 1;//无须遍历完所有元素，优化时间消耗
                }
            }
        }  
        return 0;
    }

2.最后一块石头的重量 II

问题转化为：把一堆石头分成两堆,求两堆石头重量差最小值

让两堆石头的重量差最小，相当于让其中一堆石头的重量最接近总重量的一半，所以用dp[sum/2]表示较小的那堆石头在sum/2的限制下能达到的最大重量

dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);

dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背dp[j]这么重的石头。

最后dp[target]里是容量为target的背包所能背的最大重量。

在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的,那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。。

int lastStoneWeightII(vector<int>& stones){
    int sum=0;
    vector<int> dp(15001,0);
    for(int i=0;i<stones.size();i++){//计算总和 
        sum+=stones[i];
    } 
    int target=sum/2;
    for(int i=0;i<stones.size();i++){//套用01背包 
        for(int j=target;j>=stones[i];j--){
            dp[j]=max(dp[j],dp[j-stones[i]]+stones[i]);
        }
    } 
    return sum-2*dp[target];
}

3.目标和

假设加法的总和为x，那么减法对应的总和就是sum - x。

所以我们要求的是 x - (sum - x) = S

x = (S + sum) / 2

此时问题就转化为，装满容量为x背包，有几种方法。

dp[j] += dp[j - nums[i]]

dp[i,j]=dp[i-1,j]+dp[i-1,j-nums[i]]

dp[0] = 1，理论上也很好解释，装满容量为0的背包，有1种方法，就是装0件物品。

关于状态转移方程的解释:step1:首先确定了装满容量为j的背包的方法为dp[j]； step2:从头开始遍历nums，把nums[0]放入背包，后序遍历背包容量，得到方法数dp[j] step3:把nums[1]放入背包，那么背包容量剩余j-nums[1]，那么填满背包的方法数dp[j]（此时必须放nums[1]的情况）为dp[j-nums[1]]，那么总的dp[j]= dp[j]+dp[j-nums[1]] step4.依次类推

其实背包的重量并不是目标值S，而是正数的和。所以num[1]对应的dp[1]等于2就是合理的，因为要从两个1之中选出正数和是1，确实是有两种选法。所以，这题的背包，也是把数字分两堆，一堆是正数（放进背包里的），另一堆是负数（不放背包的）。

int findTargetSumWays(vector<int>& nums, int target) {
    int sum=0;
    for(int i=0;i<nums.size();i++){//计算总和 
        sum+=nums[i];
    } 
    if(target>sum || (target+sum)%2==1){//1.全加都小再减更达不到 
        return 0;
    }
    int bagsize=(target+sum)/2;
    vector<int> dp(bagsize+1,0);
    dp[0]=1;
    for(int i=0;i<nums.size();i++){//套用01背包 
        for(int j=bagsize;j>=nums[i];j--){
            dp[j]+=dp[j-nums[i]];
        }
    } 
    return dp[bagsize];
}

4. 一和零

dp[i - zeroNum] [j - oneNum] + 1表示有i - m 个0, j- n个1时背包能放的最大子集大小, 加上当前字符串(zeroNum个0,oneNum个1)后子集数量加一, 即每个字符串的价值都是1了.

这题要将背包看作是二维背包，物品就是strs里的字符串，背包容量就是题目描述中的m和n。字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]），这里相当于每个字符串的价值都是1，理解了这些就不难了。

dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

dp[i] [j]：最多有i个0和j个1的strs的最大子集的大小为dp[i] [j]。

int findMaxForm(vector<string>& strs, int m, int n) {
    vector< vector<int> > dp(m+1, vector<int>(n + 1,0));
    for(string str:strs) {//遍历物品
        int oneNum=0, zeroNum=0;
        for(char c:str) {
            if(c=='0') zeroNum++;
            else oneNum++;
        }
        for(int i=m;i>=zeroNum;i--){
            for(int j=n;j>=oneNum;j--){
                dp[i][j]=max(dp[i][j],dp[i-zeroNum][j-oneNum]+1);
            }
        }
    }
    return dp[m][n];
}

问题：举例推导dp数组？？？