动态规划01背包问题-代码随想录-刷题笔记

最新推荐文章于 2024-08-14 22:10:41 发布
最新推荐文章于 2024-08-14 22:10:41 发布
阅读量327 收藏 1
点赞数 1
文章标签： 动态规划 笔记 算法 c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63787588/article/details/131018481
版权

image.png

理论基础

image.png

01 背包

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

二维dp数组01背包

  1. 确定dp数组以及下标的含义

是使用二维数组，即dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
image.png
2.确定递推公式
再回顾一下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得到的最大价值

所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
3.dp数组如何初始化
首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0
image.png
4.确定遍历顺序
先遍历物品，然后遍历背包重量

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

    }
}

先遍历背包，再遍历物品

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

5.举例推导dp数组
image.png

完整代码

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

01背包理论基础（滚动数组）

倒序遍历是为了保证物品i只被放入一次，把i的维度去掉了
从后往前循环，每次取得状态不会和之前取得状态重合，这样每种物品就只取一次了。
不可以更换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++) { // 遍历物品
        //倒序遍历
        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();
}

416. 分割等和子集

  1. 确定dp数组以及下标的含义

dp[j]表示 背包总容量（所能装的总重量）是j，放进物品后，背的最大重量为dp[j]。
2.确定递推公式
dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
3.dp数组如何初始化
如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。
4.确定遍历顺序
使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历
5.举例推导dp数组
image.png

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
        return dp[target] == target;
    }
};

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

  1. 确定dp数组以及下标的含义

dp[j]表示容量（其实就是重量）为j的背包，最多可以背最大重量为dp[j]
2.确定递推公式
01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
本题则是：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
3.dp数组如何初始化
因为重量都不会是负数，所以dp[j]都初始化为0就可以了
4.确定遍历顺序
如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
5.举例推导dp数组
image.png

//时间复杂度：O(m × n) , m是石头总重量（准确的说是总重量的一半），n为石头块数
//空间复杂度：O(m)
class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        vector<int> dp(1501, 0);
        int sum = 0;
        for (int i = 0; i < stones.size(); i++) sum += stones[i];
        int target = sum / 2;
        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];
    }
};

494.目标和

既然为target，那么就一定有 left组合 - right组合 = target。
left + right = sum，而sum是固定的。right = sum - left
公式来了， left - (sum - left) = target 推导出 left = (target + sum)/2 。
target是固定的，sum是固定的，left就可以求出来。
此时问题就是在集合nums中找出和为left的组合。

回溯法超时

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
        if (sum == target) {
            result.push_back(path);
        }
        // 如果 sum + candidates[i] > target 就终止遍历
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i + 1);
            sum -= candidates[i];
            path.pop_back();

        }
    }
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) sum += nums[i];
        if (S > sum) return 0; // 此时没有方案
        if ((S + sum) % 2) return 0; // 此时没有方案，两个int相加的时候要各位小心数值溢出的问题
        int bagSize = (S + sum) / 2; // 转变为组合总和问题，bagsize就是要求的和

        // 以下为回溯法代码
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 需要排序
        backtracking(nums, bagSize, 0, 0);
        return result.size();
    }
};

动态规划

x = (target + sum) / 2
此时问题就转化为，装满容量为x的背包，有几种方法。这里的x，就是bagSize
因为每个物品（题目中的1）只用一次！
这次和之前遇到的背包问题不一样了，之前都是求容量为j的背包，最多能装多少。
本题则是装满有几种方法。其实这就是一个组合问题了。

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

dp[j]:填满j（包括j）这么大容积的包，有dp[j]种方法

  1. 确定递推公式

在求装满背包有几种方法的情况下:dp[j]+=dp[j-nums[i]]

  1. dp数组如何初始化

如果数组[0] ，target = 0，那么 bagSize = (target + sum) / 2 = 0。 dp[0]也应该是1， 也就是说给数组里的元素 0 前面无论放加法还是减法，都是 1 种方法

  1. 确定遍历顺序

nums放在外循环，target在内循环，且内循环倒序。

  1. 举例推导dp数组

输入：nums: [1, 1, 1, 1, 1], S: 3
bagSize = (S + sum) / 2 = (3 + 5) / 2 = 4
image.png

//时间复杂度：O(n × m)，n为正数个数，m为背包容量
//空间复杂度：O(m)，m为背包容量
class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) sum += nums[i];
        if (abs(S) > sum) return 0; // 此时没有方案
        if ((S + sum) % 2 == 1) return 0; // 此时没有方案
        int bagSize = (S + sum) / 2;
        vector<int> dp(bagSize + 1, 0);
        dp[0] = 1;
        for (int i = 0; i < nums.size(); i++) {
            for (int j = bagSize; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bagSize];
    }
};

474.一和零

01背包有两个维度，一个是m 一个是n，而不同长度的字符串就是不同大小的待装物品。

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

dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。
2.确定递推公式
dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。
dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。
然后我们在遍历的过程中，取dp[i][j]的最大值。
所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
对比一下就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）
3.dp数组如何初始化
因为物品价值不会是负数，初始为0
4.确定遍历顺序
外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！

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

遍历背包容量的两层for循环先后循序没讲究，都是物品重量的一个维度，先遍历哪个都行！
image.png

//时间复杂度: O(kmn)，k 为strs的长度
//空间复杂度: O(mn)
class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int> (n + 1, 0)); // 默认初始化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];
    }
};
Wind哥
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
动态规划求0-1背包问题c++代码
09-10
提供0-1背包问题c++代码，实现功能如下： /**输入参数： * @param m 表示背包的最大容量 * @param n 表示商品个数 * @param a[] 每个商品的容量 * @param p[] 每个商品的价值 */ /**输出： 求最大商品value*/
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
在《代码随想录》中，可能会涵盖如斐波那契数列、背包问题、最长公共子序列等经典动态规划题目。理解动态规划的关键在于构建状态转移方程和找到正确的状态定义。 回溯（Backtracking）是一种试探性的解决问题方法，...
代码随想录1刷—动态规划篇（二）：背包问题
h0327x的博客
07-09 585
有nnn件物品和一个最多能背重量为www的背包。第iii件物品的重量是weight[i]weight[i]weight[i]，得到的价值是value[i]value[i]value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是O(2n)O(2^n)O(2n)，这里的nnn表示物品数量。所以暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化。为便于理解，先规定背包最大重量为
代码随想录背包问题总结
weixin_43821876的博客
01-25 423
代码随想录01背包和完全背包
「代码随想录」听说背包问题很难？ 这篇总结篇来拯救你了
代码随想录
02-20 815
拯救行动已经开始
数据结构-动态规划算法小结（3）-转载自（公众号：代码随想录）01背包问题
Tiehao7的博客
03-20 217
1.01背包问题dp[i][j] 1.确定dp数组以及下标的含义 dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。 2.确定递推公式 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 3.dp数组如何初始化 // 初始化 dp vector<vector<int>> dp(weight.size()...
代码随想录第36天 | ● 01背包问题，你该了解这些！ ● 01背包问题—— 滚动数组 ● 416. 分割等和子集
qq_51660693的博客
10-05 107
此时dp[j]有两个选择，一个是取自己dp[j] 相当于 二维dp数组中的dp[i-1][j]，即不放物品i，一个是取dp[j - weight[i]] + value[i]，即放物品i，指定是取最大的，毕竟是求最大价值，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]，那么dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0。在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。在这上面完了[1,2,3,4,5,6,7]，应该还有回溯可以做。
完全背包问题-代码随想录-刷题笔记
Coderwind的博客
06-06 591
完全背包问题-代码随想录-刷题笔记
源代码_背包问题--01背包_
10-02
01背包问题是一种经典的计算机科学中的动态规划问题，主要出现在算法设计和优化的领域，尤其在求解资源分配和组合优化问题时非常常见。在这个问题中，我们有一个背包，其容量有限，同时有一系列物品，每种物品都有...
「代码随想录」背包问题专题精讲（v1.0）.pdf
08-03
「代码随想录」背包问题专题精讲
01背包问题动态规划，背包问题介绍算法实现
01-21
01背包问题是一种经典的组合优化问题，主要涉及算法和动态规划。它的核心在于寻找最佳物品组合，以在不超过背包容量的限制下最大化物品的总价值。动态规划是解决这类问题的有效方法，因为它能够避免重复计算，通过...
Java学习之动态规划-背包问题代码
05-16
在所提供的压缩包文件中，"动态规划-背包问题代码.txt"很可能包含了上述逻辑的Java代码示例，而"DynamicProgramming——动态规划-背包问题详解.txt"可能提供了更详细的理论解释和分析。阅读这些文件将进一步深化你对...
动态规划 | 01背包问题理论 | 代码随想录
qq_44250700的博客
08-17 523
跟随carl代码随想录刷题 语言：python。
C++笔记5•内存管理•
qq_64446190的博客
08-12 1104
内存管理
谷粒商城实战笔记-175~177-商城业务-检索服务-检索查询接口开发
epitomizelu的专栏
08-13 756
搜索页面搭建完成之后，点击搜索按钮，发送参数给后台服务，后台服务根据参数从Elasticsearch中查询符合条件的数据，返回给前端。
经验笔记：URI、URL、URN与URC之间的区别
最新发布
qq_45831414的博客
08-14 584
URI是一种通用的标识符，可以指代任何类型的资源。URL是一种特定类型的URI，它不仅标识资源，还提供了访问该资源的方法。URN是一种用于唯一命名资源的特殊URI类型。URC是一个概念性的术语，用于描述如何构建或创建资源的过程。通过理解这些概念的区别，我们可以更加清晰地识别和使用互联网资源的标识方式。在日常工作中，我们最常遇到的是URL，因为它们是我们访问网页和其他在线资源的基础；而URN则在需要持久引用资源的情况下使用。
C++笔记4•类和对象3•
qq_64446190的博客
08-12 671
类和对象3
【Python】python中抽象类学习笔记
qq_42761751的博客
08-12 406
抽象类是一个不能被实例化的类，通常作为其他类的基类抽象方法是一个没有具体实现的方法一个抽象类可以有或者没有抽象方法, 但是一般来说定义抽象类的时候总会在类中定义抽象方法Python并没有直接支持抽象类，但是提供了一个模块（abc）来允许定义抽象类通过继承abc.ABC类定义一个抽象类pass上述代码中类虽然继承了ABC但是没有定义抽象方法，仍然可以被实例化。"""使用@abstractmethod来定义抽象方法"""passmain()代码报错：不能实例化一个带有抽象方法的抽象类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值