算法学习记录～2023.5.23～动规Day3～01背包理论基础 & 416. 分割等和子集 & 1049.最后一块石头的重量II

最新推荐文章于 2024-07-25 11:38:39 发布

山药泥拌饭

最新推荐文章于 2024-07-25 11:38:39 发布

阅读量46

点赞数

分类专栏：算法记录文章标签：算法学习

本文链接：https://blog.csdn.net/Viator_mp3/article/details/130899839

版权

算法记录专栏收录该内容

23 篇文章 0 订阅

订阅专栏

算法学习记录～2023.X.XX～章节DayX～题目号.题目标题 & 题目号.题目标题

01背包理论基础
416. 分割等和子集
1049.最后一块石头的重量II

01背包理论基础

背包九讲覆盖过全，不一定都会用的到，针对我自己的需求主要搞懂01背包就比较符合了。

整体背包问题大概如下：

在这里插入图片描述

01背包是什么

有 n 件物品和一个最多能背重量为 w 的背包。第i件物品的重量是 weight[i]，得到的价值是 value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

这是一个标准的 01 背包问题。

每一件物品其实只有 2 个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是 $o(2^n)$ ，这里的 n 表示物品数量。所以暴力解法的时间复杂度是指数级，因此需要使用动态规划的方法进行优化。

接下来都使用下面这个具体情况当作例子：

背包最大重量为 4，物品如下所示，没件物品只能用一次，问背包能装的物品最大价值为多少？

在这里插入图片描述

二维 dp 数组 01 背包

动规五步曲：

确定 dp 数组（dp table）以及下标的含义

对于背包问题，有一种写法是使用二维数组，即 dp[i][j] 表示从 0 到 i 的物品里任意取后放进容量为 j 的背包，价值的总和为多少。

需要记清楚 i ，j 以及 dp[i][j] 的具体含义。

在这里插入图片描述

确定二维 dp 数组的递推公式

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

不放物品 i ：由 dp[i - 1][j] 推出，也就是背包容量为 j 时，不放物品 i 的最大价值，那么此时 dp[i][j] 就等于 dp[i - 1][j]。
放物品 i ：由 dp[i - 1][j - weight[i]] 推出，这个也就是背包容量为 j - weight[i] 时不放物品 i 的最大价值，再加上物品 i 的价值 value[i] 即为答案。（一定要注意减去物品 i 的重量）

所以递归公式为 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])

二维 dp 数组如何初始化

初始化时一定要注意和 dp 数组的定义吻合，不然很容易弄乱。

首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0，如下图：
在这里插入图片描述
接着看其他情况。

状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。

dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量 j 的背包所能存放的最大价值。

显然当 j < weight[0] 时，dp[0][j] 为 0，因为容量比物品本身重量还小。
当 j >= weight[0] 时，dp[0][j] 为 value[0]，能够放下物品 0 ，所以价值也就是物品 0 的价值

for (int j = 0; j < weight[0]; j++){   // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略
    dp[0][j] = 0;
}
//正序遍历
for (int j = weight[0]; j <= bagweight; j++){
    dp[0][j] = value[0];
}

此时数组初始化情况如下图所示：
在这里插入图片描述
dp[0][j] 和 dp[i][0] 都已经初始化了，那么其他下标应该初始化多少呢？

其实从递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出dp[i][j] 是由左上方数值推导出来了，那么其他下标初始为什么数值都可以，因为都会被覆盖。
所以其他值可以赋值成任何数，因为一定后面会再被覆盖。
统一初始化为 0 方便些，这样比如上面 i = 0 的一部分初始化其实也能被覆盖到，能省一部分代码。

此时数组初始化情况如下图所示：
在这里插入图片描述
所以最终初始化代码为（其他初始化为 0 能省 i = 0 时的一部分代码）：

//初始化 dp 数组
vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));
for (int j = weight[0]; j <= bagweight; j++){       //合并后只有放置物品 0 时且背包容量大于等于物品 0 重量时需要赋值为value[0]
    dp[0][j] = value[0];
}

确定遍历顺序

可以看出有两个维度的遍历：物品与背包容量。

先遍历哪个都可以。

先遍历物品更好理解一点，代码如下：

for (int i = 0; i < weight.size(); i++){        // 遍历物品
    for (int j = 0; j < bagweight; j++){        // 遍历背包容量，bagweight就是背包最大承重
        if (j < weight[i])
            dp[i][j] = dp[i - 1][j];        // 背包承重小于物品 i 则肯定不能有，取不包含这个物品的前面的最大值
        else
            dp[i][j] = max(dp[i - 1][j - weight[i]] + value[i], dp[i - 1][j]);
    }
}

先遍历背包也可以，代码如下（其实只是换了两个 for 循环的顺序）：

// weight 数组的大小就是数组个数
for (int j = 0; j < bagweight; j++){        // 遍历背包容量
    for (int i = 0; i < weight.size(); i++){        // 遍历物品
        if (j < weight[i])
            dp[i][j] = dp[i - 1][j];        // 背包承重小于物品 i 则肯定不能有，取不包含这个物品的前面的最大值
        else
            dp[i][j] = max(dp[i - 1][j - weight[i]] + value[i], dp[i - 1][j]);
    }
}

因为 dp[i - 1][j - weight[i]] 和 dp[i - 1][j] 都在左上方（包括正上），所以两种遍历方式都可以

举例推导 dp 数组

如下图所示，最终结果就是dp[2][4]
在这里插入图片描述
做动态规划的题目，最好的过程就是自己在纸上举一个例子把对应的dp数组的数值推导一下，然后再动手写代码

二维 dp 测试代码

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));

    // 初始化
    for (int j = weight[0]; j <= bagweight; j++) {
        dp[0][j] = value[0];
    }

    // weight数组的大小 就是物品个数
    for(int i = 1; i < weight.size(); i++) { // 遍历物品
        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 数组（滚动数组）

对于背包问题其实状态都是可以压缩的。

在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);
与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解是一个滚动数组）。

这就是滚动数组的由来，需要满足的条件是上一层可以重复利用，直接拷贝到当前层

动规五步曲：

确定 dp 数组的定义

在一维dp数组中，dp[j]表示：容量为 j 的背包，所背的物品价值可以最大为dp[j]。

一维 dp 数组的递推公式

dp[j] 可以通过 dp[j - weight[i]] 推导出来，dp[j - weight[i]] 表示容量为 j - weight[i] 的背包能背的最大价值。

dp[j - weight[i]] + value[i] 表示容量为 j 减去物品 i 重量的背包再加上物品 i 的价值。（也就是容量为j的背包，放入物品i了之后的价值即：dp[j]）

此时 dp[j] 有两个选择，一个是取自己 dp[j] ，相当于二维 dp 数组中的 dp[i-1][j]，即不放物品 i
另一个是取 dp[j - weight[i]] + value[i]，即放物品 i

指定是取最大的，所以递归公式为
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

可以看出相对于二维 dp 数组的写法，就是把 dp[i][j] 中 i 的维度去掉了

一维 dp 数组如何初始化

dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

那么 dp[0] 就应该是0，因为背包容量为0所背的物品的最大价值就是0。

根据递归公式 dp[j] = max(dp[j], dp[j - weight[i]] + value[i])，dp数组在推导的时候一定是取价值最大的数，如果题目给的价值都是正整数那么非0下标都初始化为0就可以了。

这样才能让dp数组在递归公式的过程中取的最大的价值，而不是被初始值覆盖了

所以物品价值都大于 0 时，dp 数组全部初始化为 0 即可

一维 dp 数组遍历顺序

先看代码再讨论原理

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

最大的区别是，dp 数组设为一维时，背包容量是从大到小，也就是倒序的。这一点比较难理解。

关于这个倒序的解释可以参考这篇文章
https://blog.csdn.net/xiajiawei0206/article/details/19933781
下面摘录其中的一部分解释

最主要的思想就是 f[i][v] 是由 f[i-1][v-c[i]] 推出来的,现在要把二维的改成一维的,即要推 f[v],要保证 f[v] 由 f[v-c[i]] 推出来，
如果 v 是顺序递增的,则相当于 f[i][v] 变得是由 f[i][v-c[i]] 推出来的,而不是由原来的 f[i-1][v-c[i]] 推的。因为从前到后的话，处理后面的 f[i] 时会用到 f[v-c[i]] ，v-c[i] 一定是比 i 小的，也就是在前面，那么此时 f[v-c[i]] 已经是在 i 处处理过的了，而不是 i - 1 的状态

可以参考下面的实际举例理解：

在这里插入图片描述

f[v]=max{ f[v],f[v-c[i]]+w[i] }

首先默认值为 f[0]=0，f[1]=0，f[2]=0，f[3]=0，f[4]=0，f[5]=0，f[6]=0，f[7]=0，f[8]=0，f[9]=0，f[10]=0

当 i = 1 时，主要考虑 v > c[1]，不然连这一个都装不了减去后是负数就没意义了。
v=4:
f[4]=max{f[4],f[0]+5} max{0,5}=5 f[4]=5

v=5:
f[5]=max{f[5],f[1]+5} max{0,5}=5 f[5]=5

v=6:
f[6]=max{f[6],f[2]+5} max{0,5}=5 f[6]=5

v=7:
f[7]=max{f[7],f[3]+5} max{0,5}=5 f[7]=5

v=8:
f[8]=max{f[8],f[4]+5} max{0,10}=10 f[8]=10 (这里显然不对,这时i=1，只能放一件物品,然而没有一个物品的价值为10的 )

v=9:
f[9]=max{f[9],f[5]+5} max(0,10}=10 f[9]=10

v=10:
f[10]=max{f[10],f[6]+5} max{0,10}=10 f[10]=10

可以发现，在后面 v = 8 以后，物品 1 被用了两次，因为它用了 f[4] 的状态，而此时的 f[4] 事实上是已经处理完的 i 状态，而不是 i - 1，因此不能用从前向后。

接下来看如果是从后向前会怎样：

f[0]=0 f[1]=0 f[2]=0 f[3]=0 f[4]=5 f[5]=5 f[6]=5 f[7]=5 f[8]=5 f[9]=5 f[10]=5
v=10:
max{f[10],f[6]+5} max{0,5}=5 f[10]=5

v=9:
max{f[9],f[5]+5} max{0,5}=5 f[9]=5

v=8:
max{f[8],f[4]+5} max{0,5}=5 f[8]=5

v=7:
max{f[7],f[3]+5} max={0,5}=5 f[7]=5

v=6:
max{f[6],f[2]+5} max={0,5}=5 f[6]=5

v=5:
max{f[5],f[1]+5} max={0,5}=5 f[5]=5

v=4:
max{f[4],f[0]+5} max={0,5}=5 f[4]=5

可以很明显看到从后向前的话，用的都是未处理过的 i - 1状态，因此应该从后往前。

那么为什么二维 dp 数组遍历不需要倒序呢？

因为对于二维dp，dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖，是直接可以从上一层取数，因此本层前面的遍历也不会干扰到当前结果。

同时，一维 dp 数组的两层 for 循环，只能先遍历物品再遍历背包容量，不能更换顺序

因为一维dp的写法，背包容量一定是要倒序遍历（原因上面已经讲了），如果遍历背包容量放在上一层，那么每个 dp[j] 就只会放入一个物品，即：背包里只放入了一个物品。

倒序遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。

举例推导 dp 数组

一维dp，分别用物品0，物品1，物品2 来遍历背包，最终得到结果如下：
在这里插入图片描述

一维 dp 测试代码

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++) { // 遍历物品
        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();
}

总结

比较难理解的其实就是两个问题，第一个是一维 dp 时为什么背包容量要从后向前倒序，第二个是为什么两层 for 循环不能更改，即必须先遍历物品再遍历背包容量。
在上面通过本质思路加上具体的实例推导证明了上面两个问题，后面再看这块可以着重再加深一下这里的理解。其他的地方问题并不大。

416. 分割等和子集

题目链接

力扣题目链接

思路

本题其实就是一个01背包求总和是否能等于 sum / 2。

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

背包的体积为sum / 2
背包要放入的商品（集合里的元素）重量为元素的数值，价值也为元素的数值
背包如果正好装满，说明找到了总和为 sum / 2 的子集。
背包中每一个元素是不可重复放入

分析完上面的点就可以套用01背包解决了，同样是动规五步曲：

确定 dp 数组（dp table）以及下标的含义

01背包中的dp[j]：容量为 j 的背包，所背的物品最大价值为 dp[j]。

放在本题中，每一个元素的数值就是重量，也是价值，因此dp[j]表示背包总容量（所能装的总重量）是j，放进物品后，背的最大重量为dp[j]。
那么如果背包容量为target， dp[target]就是装满背包之后的重量，所以当 dp[target] == target 的时候，背包就装满了。

确定递推公式

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

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

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

dp 数组如何初始化

01背包的初始化为 dp 数组全部为 0

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

本题中因为要求最大价值，所以如果所有物品价值都为正整数则非 0 下标都初始化为 0 即可，如果价值有负数则非 0 下标需要初始化为负无穷。

这样才能让dp数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。

本题都是正整数的非空数组，所以全部初始化为 0

确定遍历顺序

和01背包遍历顺序相同。

需要注意的有两点：

物品遍历放在外层，背包遍历放在内层
内层 for 循环需要倒序

// 开始 01背包
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]);
    }
}

举例推导 dp 数组

dp[j]的数值一定是小于等于j的。

如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j，理解这一点很重要。

用例1，输入[1,5,11,5] 为例，最后dp[11] == 11，说明可以将这个数组分割成两个子集，使得两个子集的元素和相等，如下图：

在这里插入图片描述

代码1：carl哥题解

最后的 true 判断不是很懂为什么，按理说只要有容量能够正好为 sum / 2 的不就可以了么？

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++) {
            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;
    }
};

代码2：自己写的

主要区别在于最后的 true 判断，这样是可以通过的但是我这个解释思路是对的么？

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 == 1)       // 数值都是正整数，因此如果能分成相等的两个子集那总和一定为偶数
            return false;
        int target = sum / 2;

        //01背包
        vector<int> dp(target + 1, 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[j] == target)        //有子集能到 target 则符合要求，这样剩下部分肯定也是 target
                    return true;
            }
        }
        return false;
    }
};

总结

关于最后的true false判断，我自己是直接写在了两层 for 循环里

//01背包
        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[j] == target)        //有子集能到 target 则符合要求，这样剩下部分肯定也是 target
                    return true;
            }
        }
        return false;

提交leetcode是可以通过的，但是不知道这样可以不可以。

为什么网上的题解都是最后判断 dp[target] == target ，为什么这样才行？不是特别理解

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

题目链接

力扣题目链接

思路

可以脑测一下，如果相等就成对删除，不相等则留下差值，这样最终都会变成两个比较看全删还是留一个。

进而再往回进行思考，这两个就可以扩大为总集合中的两个子集合。

如果想让两个子集合差值最小（可以为0），那么就是让这俩尽量相等，这样问题就转化为和上面 416. 分割等和子集一样的了，无非就是最后得到 dp[target] 后的后续处理有一点差别。

如果用 sum / 2 当 target ，那么最后得到的 dp[target] 由于取整的原因一定小于等于另一半 sum - dp[target] ，因此最终结果为 (sum - dp[target]) - dp[target]

代码

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = accumulate(stones.begin(),stones.end(), 0);
        int target = sum / 2;
        vector<int> dp(target + 1, 0);
        for (int i = 0; i < stones.size(); i++){
            for (int j = target; j >= stones[i]; j--){
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return (sum - dp[target]) - dp[target];
    }
};

总结

一开始没意识到可以转化为两个子集的差，也就没有和 416. 分割等和子集关联起来

山药泥拌饭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
算法学习记录～2023.5.23～动规Day3～01背包理论基础 & 416. 分割等和子集 & 1049.最后一块石头的重量II

比较难理解的其实就是两个问题，第一个是一维 dp 时为什么背包容量要从后向前倒序，第二个是为什么两层 for 循环不能更改，即必须先遍历物品再遍历背包容量。在上面通过本质思路加上具体的实例推导证明了上面两个问题，后面再看这块可以着重再加深一下这里的理解。其他的地方问题并不大。关于最后的true false判断，我自己是直接写在了两层 for 循环里//01背包 vector < int > dp(10001 , 0);
复制链接

扫一扫