背包问题嗯

背包问题

“0-1背包”

二维数组：

// 递推公式
二维：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 
一维：dp[j] = max(dp[j], dp[j - nums[i]] + weight[i]);

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

dp数组内容变化：

0	15	15	15	15
0	15	15	max(15,0+20)=20	max(15,15+20)=35
0	15	15	20	max(35,0+30)=35

void test_2_wei_bag_problem1() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagweight = 4;

    // 二维数组
    vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));

    // 初始化
    // 背包容量分别是1，2，3，4时，且只有物品0，此时的价值：
    // 也就是说，从j=第一个物品的重量开始，遍历至背包最大容量，最大价值就是第一个物品的价值；背包容量小于第一个物品的重量时(背包装不下)，最大价值为0。
    for (int j = weight[0]; j <= bagweight; j++) {
        dp[0][j] = value[0];
    }

    // weight数组的大小 就是物品个数
    for(int i = 1; i < weight.size(); i++) { // 遍历物品，从物品1开始；
        for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
            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]);

        }
    }

    cout << dp[weight.size() - 1][bagweight] << endl;
}

int main() {
    test_2_wei_bag_problem1();
}

一维滚动数组：

// 二维数组的递推公式：

 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 

其中可以发现：二维数组中第i行的值只与第i-1行有关；

如果把dp[i -1]那一层拷贝到dp[i]，表达式变成：

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

如果用一维数组表示：

dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
//dp[j] 表示容量为j的背包所背的最大价值；

如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！

void test_1_wei_bag_problem() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;

    // 初始化
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品,从物品0开始
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量，倒序遍历
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}

int main() {
    test_1_wei_bag_problem();
}

例题 - LeetCode .416

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

实例：
输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for(int i=0;i<nums.size();i++)
        {
            sum += nums[i];
        }
        // if(sum % 2) return false;
        int target = sum/2;
        vector<int> dp(10001,0);

        for(int i=0;i<nums.size();i++)	// 外层 顺序 遍历物品
        {
            for(int j=target;j>=nums[i];j--)	// 内层 倒序 遍历背包
            {
                dp[j] = max(dp[j],dp[j-nums[i]] + nums[i]);
            }
        }
        if(dp[target] == target)
            return true;
        else
            return false;
    }
};

例题 - LeetCode .474

具有两个两个容量的背包

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

// 背包问题
// 具有两个容量的背包
class Solution {
public:
    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=='1') oneNum++;
                else zeroNum++;
            }
            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];
    }
};

例题 - LeetCode .494目标和

给你一个整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

需要进行转换

left组合 - right组合 = target
并且 left组合 + right组合 = Sum
-> 所以可以得到：left组合 = (target + Sum)/2
-> 所以转化为装容量大小为 (target + Sum)/2 的背包有多少有方法

完整代码

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int numSum = 0;
        for(int num:nums)
            numSum += num;
        if(abs(target) > numSum) return 0;		// 此时没有方法
        if((numSum+target)%2 == 1) return 0;	// 此时也没有方法
        int left = (numSum+target)/2;
        vector<int> dp(left+1,0);
        dp[0] = 1;
        for(int i=0;i<nums.size();i++)	// 外层 顺序 遍历物品
        {
            for(int j=left;j>=nums[i];j--)	// 内层 倒序 遍历背包
            {
                dp[j] = dp[j]+dp[j-nums[i]];	// dp推导公式 - 求方法数的都是这个公式
            }
        } 
        return dp[left];
    }
};

完全背包

物品可以无限重复取

内层循环为顺序遍历背包

例题 - LeetCode .322

确定dp公式;

dp[j] : 数值和为 j 时，硬币最少数量
i : 硬币数值
dp[j] = min(dp[j],dp[j-i] + 1);

实例：
输入：coins = [1, 2, 5], amount = 5
输出：1
解释：5 = 5

下标(和)：	0	1	2	3	4	5
dp[i] (数量)	0	1	1	2	2	1

实例：
输入：coins = [1, 2, 5], amount = 11
输出：3
解释：5+5+1

dp	0	1	2	3	4	5	6	7	8	9	10	11
dp[j]	0	1	2	3	4	5	6	7	8	9	10	11
dp[j]			1	2	2	3	3	4	4	5	5	6
dp[j]						1	2	2	3	3	2	3

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount+1,INT_MAX);
        dp[0] = 0;
        for(int i=0;i<coins.size();i++)			// 外层 顺序 遍历物品
        {
            for(int j=coins[i];j<=amount;j++)    // 内层完全背包- 顺序 遍历背包
            {
                if(dp[j-coins[i]] == INT_MAX)        // 如果不存在dp[j-coin[i]]数值的硬币，则跳过
                    continue;
                else
                    dp[j] = min(dp[j],dp[j-coins[i]]+1);
            }
        }
        // 如果没有任何一种硬币组合能组成总金额，返回-1;
        if(dp[amount] == INT_MAX) return -1;        
        else return dp[amount];
    }
};

例题 - LeetCode .518

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

// 求组合数
class Solution {
public:
    int change(int amount, vector<int>& coins) {
        // dp[j]：数值和为j，硬币的组合方式数；
        vector<int> dp(amount+1,0);
        dp[0] = 1;
        // 先遍历物品，再遍历背包
        for(int i=0;i<coins.size();i++)
        {
            for(int j=coins[i];j<=amount;j++)
            {
                dp[j] = dp[j] + dp[j-coins[i]]; // dp公式：dp[j] = dp[j] + dp[j-coins[i]];
            }
        }
        return dp[amount];
    }
};

// 求排列数
// 只能先遍历背包，再遍历物品
for(int j=0;j<=amount;j++)
{
    for(int i=0;i<coins.size();i++)
    {
        if(j-coins[i] >= 0)
            dp[j] += dp[j - coins[i]];
    }
}