动态规划:01背包问题全解

最新推荐文章于 2024-06-20 09:44:35 发布
最新推荐文章于 2024-06-20 09:44:35 发布
阅读量1k 收藏
点赞数
文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74846930/article/details/132265132
版权

01背包

一、前言

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

这是最标准的01背包问题，以至于我们有时看到了这个自然就会想到背包，甚至都不知道暴力的解法应该怎么解了。

这样其实是没有从底向上去思考，而是习惯性想到了背包，那么暴力的解法应该是怎么样的呢？

每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是O（n*n），这里的n表示物品数量。由于时间复杂度过高，我们才会想到用动态规划来解决这一系列问题

二、动态规划思想

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

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

2.确定递推公式

让我们再回顾一下dp[i][j]的含义：从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。由此我们可以根据一下两个方向来确定递推公式：

不放物品i:此时dp[i][j]=dp[i-1][j]，我们的dp含义已经是最大价值总和了，此时如果不选物品i，那么在背包容量为j的情况下挑选前i件物品的最大价值就等于在背包容量为j的情况下挑选前i-1件物品

放物品i：此时dp[i][j]=dp[i-1][j-weight[i]]+value[i]，选择物品i后背包容量为j，那么在没选物品i时，相当于以j-weight[i]这一背包容量在前i-1件物品中挑取的最大价值，并加上i的价值

综上所述，因为我们要做出选当前物品和不选当前物品中价值最大的那一步选择，所以最后确定的递推公式为：

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

3.初始化

首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。

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

那么很明显当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。

当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。

// 初始化 dp
vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}

4.确定遍历顺序

遍历分为两种，一种是先遍历背包，后遍历物品，另外一种是先遍历物品，后遍历背包。在01背包中先遍历背包和先遍历物品都是可以的

先遍历物品，后遍历背包

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

三、滚动数组内存优化

由上述的递推表达式 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]) ，我们可以清晰的发现任何一个此时选区的i物品的状态都依赖且只依赖于选取i-1物品时的状态，因此我们可以给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[j]=dp[j-weight[i]]这一步，因为是这一轮大容量背包可能找上一轮小容量背包要答案，如果此时背包在从小到大遍历，你这一步大容量背包找的小容量背包不再是上一轮了，而是这一轮的小容量背包，因此我们需要从后往前遍历容量，确保你大容量背包找的小容量背包是上一轮未被修改过的

四、Leetcode实战

当然大多数此类问题会在我们刚刚讲的经典01背包基础上做一些变化，我们需要根据最基础的01背包理论将这些问题转化为我们能够熟悉的01背包，然后再解决它们

Leetcode.416 分割等和子集

方法一：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
    //01背包问题转化思路:在0...i中选取nums中的元素，能否恰好装满容量为nums和一半的背包
    //dp数组及其含义:dp[i][j]-->前i里面挑，能否挑出和为j
    //递推公式：dp[i][j]=dp[i-1][j]|dp[i-1][j-nums[i]]
    //初始化:dp[i][0]=true dp[0][nums[0]]=true
    int total=0;
    for(int i=0;i<nums.size();i++){
    total+=nums[i];
    }
    if(total%2!=0)return false;//base case:总和为奇数直接返回
    int target=total/2;
    //创建dp数组
    vector<vector<bool>>dp(nums.size(),vector<bool>(target+1,false));
    //进行dp数组的初始化
    for(int i=0;i<nums.size();i++){
        dp[i][0]=true;
    }
    if(target>=nums[0])
    dp[0][nums[0]]=true;
    for(int i=1;i<nums.size();i++){
        for(int j=1;j<=target;j++){
            if(j<nums[i])dp[i][j]=dp[i-1][j];
            else dp[i][j]=dp[i-1][j]|dp[i-1][j-nums[i]];
        }
    }
    return dp[nums.size()-1][target];

    }
};

滚动数组优化:

class Solution {
public:
    bool canPartition(vector<int>& nums) {
    int total=0;
    for(int i=0;i<nums.size();i++){
    total+=nums[i];
    }
    if(total%2!=0)return false;
    int target=total/2;
    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[target]==target)return true;
        }
    }
    return false;

    }
};

方法二：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
    //01背包问题转化思路:在0...i中选取nums中的元素，能否恰好装满容量为nums和一半的背包
    //dp数组及其含义:dp[i][j]-->前i里面挑，容量为j的背包最大价值(每件物品的价值等于其重量)
    //递推公式：dp[i][j]=max(dp[i-1][j],dp[i-1][j-nums[i]]+nums[i])
    //初始化:dp[0][nums[0]...target]=nums[0]
    int total=0;
    for(int i=0;i<nums.size();i++){
    total+=nums[i];
    }
    if(total%2!=0)return false;//base case:总和为奇数直接返回
    int target=total/2;
    //创建dp数组
    vector<vector<int>>dp(nums.size(),vector<int>(target+1,0));
    //进行dp数组的初始化
    for(int i=nums[0];i<=target;i++){
        dp[0][i]=nums[0];
    }
    for(int i=1;i<nums.size();i++){
        for(int j=1;j<=target;j++){
            if(j<nums[i])dp[i][j]=dp[i-1][j];
            else dp[i][j]=max(dp[i-1][j],dp[i-1][j-nums[i]]+nums[i]);
        }
    }
    return dp[nums.size()-1][target]==target;

    }
};

 滚动数组优化:

class Solution {
public:
    bool canPartition(vector<int>& nums) {
    int total=0;
    for(int i=0;i<nums.size();i++){
    total+=nums[i];
    }
    if(total%2!=0)return false;
    int target=total/2;
    //创建dp数组
    vector<bool>dp(target+1,false);
    dp[0]=true;
    //进行dp数组的初始化
    for(int i=0;i<nums.size();i++){
        for(int j=target;j>=nums[i];j--){
         dp[j]=dp[j]|dp[j-nums[i]];
         if(dp[target])return true;
        }
    }
    return false;

    }
};

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

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
    int total=0;
    for(int val:stones){
        total+=val;
    }
    int target=total/2;
    vector<vector<int>>dp(stones.size(),vector<int>(target+1,0));
    //容量为target的背包最多能装多少价值的物品，价值就正好等于重量
    for(int i=stones[0];i<=target;i++){
        dp[0][i]=stones[0];
    }
    for(int i=1;i<stones.size();i++){
        for(int j=1;j<=target;j++){
            if(j>=stones[i])dp[i][j]=max(dp[i-1][j],dp[i-1][j-stones[i]]+stones[i]);
            else dp[i][j]=dp[i-1][j];
        }
    }
    return total-2*dp[stones.size()-1][target];

    }
};

滚动数组优化:

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
    int total=0;
    for(int val:stones){
        total+=val;
    }
    int target=total/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 total-2*dp[target];

    }
};

Leetcode.494 目标和

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
    //设加法总数为x，那么减法总数为sum-x,那么target需要等于2*x-sum,x=target+sum/2
    int sum=0;
    for(int val:nums){
    sum+=val;
    }
    if(sum<abs(target))return 0;
    if((sum+target)%2!=0)return 0;
    target=(target+sum)/2;
    vector<vector<int>>dp(nums.size(),vector<int>(target+1,0));
    //背包能够装出价值为x的个数
    //递推公式:dp[i][j]=max(dp[i-1][j],dp[i-1][j-nums[i]]+1)
    if(nums[0]<=target)dp[0][nums[0]]=1;
    if(nums[0]==0)dp[0][0]=2;
    else dp[0][0]=1;
    for(int i=1;i<nums.size();i++){
        if(nums[i]==0)dp[i][0]=2*dp[i-1][0];
        else dp[i][0]=dp[i-1][0];
    }
    for(int i=1;i<nums.size();i++){
        for(int j=1;j<=target;j++){
            if(j>=nums[i])dp[i][j]=dp[i-1][j]+dp[i-1][j-nums[i]];
            else dp[i][j]=dp[i-1][j];
        }
    }
    return dp[nums.size()-1][target];

    }
};

 滚动数组优化：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
    int sum=0;
    for(int val:nums){
        sum+=val;
    }
    if((sum+target)%2!=0||sum<abs(target))return false;
    vector<int>dp((sum+target)/2+1,0);
    dp[0]=1;
    for(int i=0;i<nums.size();i++){
        for(int j=dp.size()-1;j>=nums[i];j--){
            dp[j]+=dp[j-nums[i]];
        }
    }
    return dp[dp.size()-1];
    }
};

Leetcode.474 一和零

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
    //dp[i][j][k]--->挑选前i个字符串,所选出来有j个0和k个1的最大子集
    //dp[i][j][k]=max(dp[i-1][j][k],dp[i-1][j-zeroNum][k-oneNum]+1)
    //初始化:将下标为0的字符串中的0和1统计一下，dp[0][i>=zeroNum][j>=oneNum]=1
    vector<vector<vector<int>>>dp(strs.size(),vector<vector<int>>(m+1,vector<int>(n+1,0)));
    int zeroNum=0;
    int oneNum=0;
    for(char c:strs[0]){
        if(c=='0')zeroNum++;
        else oneNum++;
    }
    for(int i=zeroNum;i<=m;i++){
        for(int j=oneNum;j<=n;j++){
            dp[0][i][j]=1;
        }
    }
    for(int i=1;i<strs.size();i++){
        zeroNum=0;
        oneNum=0;
        for(char c:strs[i]){
            if(c=='0')zeroNum++;
            else oneNum++;
        }
        for(int j=0;j<=m;j++){
            for(int k=0;k<=n;k++){
                if(j>=zeroNum&&k>=oneNum)
                dp[i][j][k]=max(dp[i-1][j][k],dp[i-1][j-zeroNum][k-oneNum]+1);
                else dp[i][j][k]=dp[i-1][j][k];
            }
        }
    }
    return dp[strs.size()-1][m][n];
    }
};

省去初始化的代码:外围数组扩一圈在for循环中进行初始化，注意，该方法仅仅是使代码更加简洁，实际上不会减少时间，反而会增加空间

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {        
    vector<vector<vector<int>>>dp(strs.size()+1,vector<vector<int>>(m+1,vector<int>(n+1,0)));
    
    for(int i=1;i<=strs.size();i++){
       int zeroNum=0;
       int oneNum=0;
        for(char c:strs[i-1]){
            if(c=='0')zeroNum++;
            else oneNum++;
        }
        for(int j=0;j<=m;j++){
            for(int k=0;k<=n;k++){
                if(j>=zeroNum&&k>=oneNum)
                dp[i][j][k]=max(dp[i-1][j][k],dp[i-1][j-zeroNum][k-oneNum]+1);
                else dp[i][j][k]=dp[i-1][j][k];
            }
        }
    }
    return dp[strs.size()][m][n];
    }
};

滚动数组优化：

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 zeroNum=0;
            int oneNum=0;
            for(char a:str){
                if(a=='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];
    }
};

 

嶋野之狂犬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
动态规划：01背包问题
CY2333333的博客
06-06 7028
       01背包问题是最基本的背包问题，其题意可大概描述为一共有N件物品，每件物品都有其相应的体积和价值，给你一个背包，背包有容量上限，怎样往背包中装物品，能让背包中的物品价值最高。        此类问题是典型的动态规划问题，动态规划的目标是背包中物品的总价值，动态规划的变量是物品的体积和价值，以及背包的容量上限，经过分析，我们可以定义一下dp状态： &nbsp
【算法】----01背包问题（动态规划）
云小逸的博客
03-26 2701
今天我们来学习一下一个经典Dp问题----背包问题，这里将详细介绍背包问题的二维解法和一维解法。码字不易，请多多支持。
刷代码随想录有感（109）：动态规划——01背包问题|一和零
最新发布
m0_74073296的博客
06-20 196
将m, n视为背包的属性，故问题转化为了将m,n容量的背包转满最多能装多少个，而每样物品只能装一次，问题转化成了01背包问题。实际上是三维数组，只不过背包有两个属性而已，用类似是一维数组方法写。
动态规划背包问题之01背包详解
晨的博客
07-16 4万+
动态规划背包问题之01背包详解
动态规划——0/1背包问题(全网最细+图文解析)
Biteht的博客
05-08 6万+
01背包你真的掌握了吗?进来带你10分钟秒杀
0-1背包的四种解法
星辰的博客
11-27 1万+
有句老话说得好，学会了0-1背包就学会了算法。本篇博客就来盘点一下0-1背包的4中常见解法。 动态规划法 既然要用动态规划法解0-1背包问题，就要能满足动态规划的两个特性： 具有重叠子问题。 具有最优子结构性。 这两点应该很容易就可以看出，这里就不做过多赘述了。 直接来看关键，之前说过，动态规划的本质就是填表，而解动态规划问题的关键是找出动态转移方程，一旦找出动态转移方程，就可以用方程把整个表都填满了。 这里直接给出动态转移方程 V(i, j)表示在前i(1≤i≤n)个物品中能够装入容量为j（1≤j≤C
【动态规划算法】背包问题——0/1背包问题，多目标优化背包问题详解与示例
qq_35831906的博客
11-13 9959
背包问题是动态规划中的一个经典问题，通常有两种主要变种：0/1 背包问题和背包问题（Fractional Knapsack Problem）。这里我们先详细解释0/1背包问题再介绍背包问题的变种。
01背包问题详解（浅显易懂）
Iseno_V的博客
08-21 10万+
01背包问题详解 01背包是一种动态规划问题。动态规划的核心就是状态转移方程，本文主要解释01背包状态转移方程的原理。 问题描述 01背包问题可描述为如下问题： 有一个容量为V的背包，还有n个物体。现在忽略物体实际几何形状，我们认为只要背包的剩余容量大于等于物体体积，那就可以装进背包里。每个物体都有两个属性，即体积w和价值v。 问：如何向背包装物体才能使背包中物体的总价值最大？ 为什么不用贪心？ ...
c++用动态规划实现01背包问题
10-20
01背包问题是一种经典的组合...总的来说，C++通过动态规划解决01背包问题，不仅锻炼了算法设计能力，也体现了C++在处理复杂计算问题上的优势。通过阅读和理解这样的程序，你可以深入学习动态规划思想和C++编程技巧。
动态规划解决01背包问题
01-17
01背包是在M件物品取出若干件放在空间为W的背包里，每件物品的体积为W1...动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。
动态规划-01背包问题
11-16
01背包问题是一种经典的计算机科学优化问题，主要应用于资源分配、任务调度等领域，它通过动态规划的方法求解最优解。动态规划是一种解决复杂问题的有效算法，通过将问题分解为更小的子问题，并存储子问题的解以避免...
什么是01背包问题动态规划以及学习01背包问题动态规划的意义
05-09
01背包问题动态规划
01背包问题动态规划，背包问题介绍算法实现
01-21
01背包问题是一种经典的组合优化问题，主要涉及算法和动态规划。它的核心在于寻找最佳物品组合，以在不超过背包容量的限制下最大化物品的总价值。动态规划是解决这类问题的有效方法，因为它能够避免重复计算，通过...
01背包问题
ccc369639963的博客
01-19 1万+
01背包问题 商店的货架上摆放着不同重量和价值的商品，一个小偷在商店行窃，他携带的背包只能装固定重量的商品。装哪些商品才能获得最大的收益呢？在限定条件内找到最佳的物品组合，这样的问题统称为背包问题。 根据限定的条件不同，背包问题还可以细分： 部分背包问题：所有物品是可再分的，即允许将某件物品的一部分（例如 1/3）放入背包； 0-1 背包问题：所有物品不可再分，要么整个装入背包，要么放弃，不允许出现“仅选择物品的 1/3 装入背包”的情况； 完全背包问题：不对每一件物品的数量做限制，同一件物品可以选择多个装
动态规划之01背包问题（最易理解的讲解）
热门推荐
mu399的专栏
07-06 42万+
01背包问题，是用来介绍动态规划算法最经典的例子，网上关于01背包问题的讲解也很多，我写这篇文章力争做到用最简单的方式，最少的公式把01背包问题讲解透彻。 01背包的状态转换方程 f[i,j] = Max{ f[i-1,j-Wi]+Pi( j >= Wi ),  f[i-1,j] } f[i,j]表示在前i件物品中选择若干件放在承重为 j 的背包中，可以取得的最大价值。 Pi表示第i件物
算法中的01背包问题怎么解决
weixin_35757191的博客
02-12 658
01背包问题是一种常见的动态规划问题，主要用于解决在限制条件下，如何获得最大价值或最大收益的问题。 具体来说，01背包问题是指：给定一组物品，每种物品都有自己的价值和体积，同时有一个背包，背包的容积是有限的，每种物品只能放入一次。问在不超过背包容积的前提下，如何选择物品，使得背包中的物品的价值最大。 解决01背包问题的方法是使用动态规划算法，具体步骤如下： 定义状态：设f[i][j]表示前i件物...
动态规划-（0-1）背包问题
菜鸟的博客
10-29 1万+
下面我用容积代表重量（我是不会承认我看走眼了的。又懒得改。）0-1背包问题是动态规划背包问题系列的最基础的一个问题。相对理解起来较为简单。按书上来说，要证明一个问题是否可以使用动态规划思想，需要满足最优子结构的性质，那么什么是最优子结构的性质呢？书上给出的定义如下图看起来很拗口，其实就是不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。说白了就是一个最优策略的子策略也是必须是最优的，而所有子问题的局部最优解将导致整个问题的全局最优。
01背包——优化详解！！！（滚动数组、一维优化）
qq_60466872的博客
07-07 1249
可以看出，dp[i,j]只依赖与自己和i-1，而滚动数组就是把i给变成2，反复用0、1来进行dp，上一轮的值还是可以找到。原来空间复杂度:O(NV) 滚动数组优化后空间复杂度：O(2*N)dp[i,j]:1~i个物品组成重量
关于完全背包的解析以及完全背包与01背包的区别及代码
weixin_59867637的博客
01-25 1709
关于完全背包的解析以及完全背包与01背包的区别及代码
动态规划:01背包问题
04-05
01背包问题是动态规划中的经典问题之一。问题描述如下： 给定一个背包和一些物品，每个物品有自己的重量和价值。背包有一个最大重量限制，问如何选择物品放入背包，可以使得背包中物品的总价值最大。 这个问题可以用动态规划求解。定义一个二维数组dp，其中dp[i][j]表示在前i个物品中选取一些物品放入容量为j的背包中所能获得的最大价值。则有以下状态转移方程： dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i]) 其中，w[i]表示第i个物品的重量，v[i]表示第i个物品的价值。 初始状态为dp[0][j] = 0，dp[i][0] = 0。 最终的答案为dp[n][W]，其中n为物品的个数，W为背包的最大容量。 下面是Python代码实现： ``` def knapsack(n, W, w, v): dp = [[0] * (W+1) for _ in range(n+1)] for i in range(1, n+1): for j in range(1, W+1): if j < w[i-1]: dp[i][j] = dp[i-1][j] else: dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i-1]]+v[i-1]) return dp[n][W] ``` 其中，n表示物品的个数，W表示背包的最大容量，w和v分别表示物品的重量和价值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值