背包问题详解

最新推荐文章于 2023-08-20 23:50:48 发布
最新推荐文章于 2023-08-20 23:50:48 发布
阅读量225 收藏 1
点赞数 3
分类专栏： Acwing算法模板 文章标签： c语言 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45627369/article/details/119406496
版权

背包问题

0-1背包

dp问题思路

(一）状态表示（i,j)//i为物品个数，j为背包最大容量
1.集合
(1)所有选法
(2)条件
i.只从前i个物品里选
ii.选择物品总容量≤j
2.属性
Max,(Min,数量)

(二）状态计算
1. 集合划分f(i,j)
1.不含第i件物品（在1~i-1件物品里选)—f(i-1,j)
2.当j≥v[i]时 ，可能含第i件物品（在第1~i件物品里选,必须包含i)—f(i-1,j-v[i])+w[i]
f(i,j)=max( f(i-1,j) , f(i-1,j-v[i])+w[i]) )
2. 两个原则：
1.不重复
2.不漏选
每件物品最多装入一次

二维

#include <iostream>
#include <algorithm>
using namespace std;  
const int N=1010;
int v[N];
int w[N];
int dp[N][N];
int n,m;
int main(){
    
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++){
        scanf("%d%d",&v[i],&w[i]);
    }
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
          if(j>=v[i])dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);
          else dp[i][j]=dp[i-1][j];
        }
    }
   printf("%d",dp[n][m]);
    
    return 0;
}

转化成一维

当计算f(i,j)是只用到了i-1且≤j,所以可以用滚动数组算,可将二维转化为一维：
删掉了第一维：在前i个物品中取。
f[j]表示：拿了总体积不超过j的物品，最大总价值。

为何能转化为一维？
二维时的更新方式：f[i][j]=max(f[i - 1][j] ,f[i - 1][j - v[i]] + w[i]);
1.对于每次循环的下一组i，只会用到i-1来更新当前值，不会用到i-2及之前值。于是可以在这次更新的时候，将原来的更新掉，反正以后也用不到。
所以对于i的更新，只需用一个数组，直接覆盖就行了。
2.对于每次j的更新，只需用到之前i-1时的j或者j-v[i]，不会用到后面的值。
所以为了防止串着改，我们采取从后往前更新的方式，用原来i-1的数组来更新i。
（如果从前往后更新的话，前面的更新过之后，会接着更新后面的值，这样就不能保证是用原来i-1的数组来更新i的了）

如何转化为一维呢？
只用一个数组，每次都覆盖前面的数组。
1.如果当前位置的东西不拿的话，和前一位置的信息（原来i-1数组的这个位置上的值）是相同的，所以不用改变。
2.如果当前位置的东西拿了的话，需要和前一位置的信息（原来i-1数组的这个位置上值）取max。

所以，更新方式就为：
f[j]=max(f[j],f[j-v[i]]+w[i]);
整个更新方式就相当于：
每次i++，就从后往前覆盖一遍f数组，看每个位置上的值是否更新。

一维

#include <iostream>
#include <algorithm>
using namespace std;  
const int N=1010;
int v[N];
int w[N];
int dp[N];
int n,m;
int main(){
    
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++){
        scanf("%d%d",&v[i],&w[i]);
    }
    
    for(int i=1;i<=n;i++){
        for(int j=m;j>=v[i];j--){
          dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
        }
    }
   printf("%d",dp[m]);
    
    return 0;
}

完全背包问题

每件物品有无限个
dp问题思路

(一）状态表示（i,j)//i为物品个数，j为背包最大容量
1.集合
(1)所有选法
(2)条件
i.只从前i个物品里选
ii.选择物品总容量≤j
2.属性
Max

(二）状态计算
1. 集合划分f(i,j)
第i件物品可选择0~k个
(1)选择0个 f[i-1][j]
(2)选择k个
i.去掉k个物品i
ii.求Max f(i-1,j-kv[i])
iii.加上k个物品i f(i-1,j-kv[i])+k*w[i]
在这里插入图片描述
2. 两个原则：
1.不重复
2.不漏选

#include <iostream>
#include <algorithm>
using namespace std;
const int N=1100;
int v[N],w[N];
int dp[N][N];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++){
        scanf("%d%d",&v[i],&w[i]);
    }
    
    for(int i=1;i<=n;i++){
       for(int j=0;j<=m;j++){
          for(int k=0;k*v[i]<=j;k++){
             dp[i][j]=max(dp[i][j],dp[i-1][j-v[i]*k]+k*w[i]);
          }
       }
    }
    
    printf("%d",dp[n][m]);
    return 0;
}

优化
在这里插入图片描述

#include <iostream>
#include <algorithm>
using namespace std;
const int N=1100;
int v[N],w[N];
int dp[N][N];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++){
        scanf("%d%d",&v[i],&w[i]);
    }
    
    for(int i=1;i<=n;i++){
       for(int j=0;j<=m;j++){
             if(v[i]<=j)dp[i][j]=max(dp[i-1][j],dp[i][j-v[i]]+w[i]);
             else dp[i][j]=dp[i-1][j];
       }
    }
    
    printf("%d",dp[n][m]);
    return 0;
}

发现与01背包很相似，可以利用滚动数组做进一步优化
与01背包不同的是dp[i][j]利用的是dp[i][j-v[i]]+w[i]进行更新，即在已更新的dp结果上进行更新，所以j由小到大

#include <iostream>
#include <algorithm>
using namespace std;
const int N=1100;
int v[N],w[N];
int dp[N];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++){
        scanf("%d%d",&v[i],&w[i]);
    }
    
    for(int i=1;i<=n;i++){
       for(int j=v[i];j<=m;j++){
            dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
       }
    }
    
    printf("%d",dp[m]);
    return 0;
}

多重背包

每个物品最多有si个
问题思路

(一）状态表示（i,j)//i为物品个数，j为背包最大容量
1.集合
(1)所有选法
(2)条件
i.只从前i个物品里选
ii.选择物品总容量≤j
2.属性
Max

(二）状态计算
1. 集合划分f(i,j)
第i件物品可选择0~k个
(1)选择0个 f[i-1][j]
(2)选择k个
i.去掉k个物品i
ii.求Max f(i-1,j-kv[i])
iii.加上k个物品i f(i-1,j-kv[i])+k*w[i]，k∈(0,si)
在这里插入图片描述

相当于滑动窗口最大值，必须用单调队列进行优化

朴素版

#include <iostream>
#include <algorithm>
using namespace std;
const int N=1010;
int v[N],w[N],s[N];
int dp[N][N];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++){
        scanf("%d%d%d",&v[i],&w[i],&s[i]);
    }
    for(int i=1;i<=n;i++){
        for(int j=0;j<=m;j++){
            for(int k=0;k<=s[i]&&k*v[i]<=j;k++){
               dp[i][j]=max(dp[i][j],dp[i-1][j-k*v[i]]+k*w[i]);
                
            }
        }
    }
    
    printf("%d",dp[n][m]);
    return 0;
}

优化版
在这里插入图片描述
不能直接用完全背包的方式进行优化
已知前n-1个数最大值，求不出第n个数最大值
优化方法：二进制
0,1,2,4…2k 可以凑出0~2k+1-1的数
0,1,2,4…2k,c (c≤2k+1) 可以凑出0~s的数
用将原来第i个物品按1,2,4,…进行打包,用打包后物品表示新的物品
可以把O(n)一维线性问题优化为O(logn)
原问题时间复杂度变为O(NVlogS)
将多重背包问题转化为01背包问题

#include <iostream>
#include <algorithm>
using namespace std;
const int N=24000,M=2000;
int v[N],w[N];
int dp[N];
int main(){
    int n,m;
    int cnt=0;
   scanf("%d%d",&n,&m);
   
   for(int i=1;i<=n;i++){
      int a,b,s;
      scanf("%d%d%d",&a,&b,&s);
      int k=1;
      while(k<=s){
          cnt++;
          v[cnt]=a*k;
          w[cnt]=b*k;
          s-=k;
          k*=2;
      }
      
      if(s>0){
         cnt++;
         v[cnt]=a*s;
         w[cnt]=b*s;
      }
   }
   n=cnt;
   for(int i=1;i<=n;i++){
       for(int j=m;j>=v[i];j--){
          dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
         
       }
   }
   printf("%d",dp[m]);
    return 0;
}

分组背包

物品分为n组，每组有若干种，枚举第i组物品最多选其中一个
第i组物品一个都不选dp[i-1,j]
第i组物品选第k个dp[i-1][j-v[i,k]]+w[i,k]
朴素版

#include <iostream>
#include <algorithm>
using namespace std;
const int N=110;
int v[N][N],w[N][N],s[N];
int dp[N][N];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        
        scanf("%d",&s[i]);
        for(int j=1;j<=s[i];j++){
            scanf("%d%d",&v[i][j],&w[i][j]);
        }
    }
    
    for(int i=1;i<=n;i++){
       for(int j=0;j<=m;j++){
           for(int k=0;k<=s[i];k++){
               if(j>=v[i][k])dp[i][j]=max(dp[i][j],dp[i-1][j-v[i][k]]+w[i][k]);
           }
       }
    }
    printf("%d",dp[n][m]);
    return 0;
}

优化版

#include <iostream>
#include <algorithm>
using namespace std;
const int N=110;
int v[N][N],w[N][N],s[N];
int dp[N];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        
        scanf("%d",&s[i]);
        for(int j=1;j<=s[i];j++){
            scanf("%d%d",&v[i][j],&w[i][j]);
        }
    }
    
    for(int i=1;i<=n;i++){
       for(int j=m;j>=0;j--){
           for(int k=0;k<=s[i];k++){
               if(j>=v[i][k])dp[j]=max(dp[j],dp[j-v[i][k]]+w[i][k]);
           }
       }
    }
    printf("%d",dp[m]);
    return 0;
}
折叠的饼干
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【最全面详细解释】背包问题详解
qq_43108684的博客
05-27 3268
文章目录一、背包问题二、解法一1.思路三、解法二1.思路 一、背包问题 背包问题： 一个背包最多可放重量为weight的物品，现在有n件物品的集合S,物品的重量分别为[w0,w1,w2,w3…w n-1]. 问题是能够从这n件物品中取出若干件物品刚好装满这个背包，不考虑背包的容积，只考虑重量，检查这个问题是否有解，有解就输出Yes,没有则输出No. 二、解法一 1.思路 解题思路： 先假设weight>=0,n >=0, knap(weight,n)表示n件物品相对于总重量weight的背包问
背包问题看这一篇就够了（详细版）
qq_54779611的博客
07-28 1万+
我们常说的背包问题其实分为好多种主要分为以下几种：01背包，完全背包，多重背包，分布背包。 所有的背包问题都是在有限V体积的背包中挑选物品，物品的属性分为w[i],v[i]表示第i个物品的价值和体积。从中找出那个能得到最大价值的选物品的方案。 通俗的来讲就是给你一个背包让你去装钻石每个钻石的价值和体积都是不一样的，最后你要装到最大价值的钻石。然后输出最大价值。 想要搞清楚这几种背包首先应该明白这几种背包的区别： 01背包 （每个物品只有一个，要么只选一个要么不选） 完全背包（每个物品有无数多个）
算法数据结构——背包问题详解（第一篇）
学习中
08-20 416
算法数据结构——背包问题详解（第一篇）
背包问题算法全解析：动态规划和贪心算法详解
BASK2312的博客
04-28 3868
计算机背包问题是动态规划算法中的经典问题。本文将从理论和实践两个方面深入探讨计算机背包问题，并通过实际案例分析，帮助读者更好地理解和应用该问题。
python基于递归解决背包问题详解
09-19
主要介绍了python基于递归解决背包问题，递归是个好东西，任何具有递归性质的问题通过函数递归调用会变得很简单。一个很复杂的问题，几行代码就能搞定,需要的朋友可以参考下
背包问题详解及C语言实现.zip
03-30
背包问题 背包问题（Knapsack problem）是一种组合优化的NP完全问题，其问题描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，如何选择才能使得物品的总价格最高。这个问题名称来源于如何...
01背包问题详解,附带源码
最新发布
05-16
01背包问题详解,附带源码01背包问题详解,附带源码01背包问题详解,附带源码01背包问题详解,附带源码01背包问题详解,附带源码01背包问题详解,附带源码01背包问题详解,附带源码01背包问题详解,附带源码01背包问题详解,...
背包问题（四种）
m0_53565874的博客
03-02 1万+
背包问题 文章目录背包问题一、背包模型（定义）二、01背包题目输入格式输出格式数据范围输入样例输出样例：题意思路二维AC代码一维AC代码三、完全背包题目输入格式输出格式数据范围输入样例输出样例：思路1朴素TLE代码思路2二维AC代码一维AC代码四、多重背包多重背包问题I题目输入格式输出格式数据范围输入样例输出样例：思路暴力AC代码多重背包问题II题目输入格式输出格式数据范围提示：输入样例输出样例：AC代码五、分组背包题目输入格式输出格式数据范围输入样例输出样例：思路AC代码 一、背包模型（定义） 01背包：
背包问题(0-1背包，完全背包，多重背包知识概念详解)
06-14
背包问题(0-1背包，完全背包，多重背包知识概念详解)内含实例代码解析,详细讲解了背包的基本概念及简单运用问题
【动态规划】背包问题（详细总结，很全）
热门推荐
m0_51370744的博客
10-07 2万+
暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！背包问题是动态规划（Dynamic Planning） 里的非常重要的一部分,关于几种常见的背包，其关系如下：在解决背包问题的时候，我们通常都是按照如下五部来逐步分析，把这五部都搞透了，算是对动规来理解深入了。二维dp数组01背包，先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历一维dp数组01背包，只能先遍历物品再遍历背包容量，且第二层for循环是从大到小遍历。求组合数：外层遍历物品，内层遍历背包。
背包九讲——九种背包问题的算法思路+代码分析
鱼香rose_的博客
08-04 2799
其实九种背包问题都是由01背包问题延伸而来，因为其他背包问题都是在01背包问题上加了一些其他条件或限制。只要01背包的思想完全掌握，那么在学习其他背包问题的时候都能够很快理解，在解决其他背包问题时基本只是在01背包基础上，增加一些判断，或是在01背包思想的基础上根据题目要求做出一些调整。因此本篇在刚开始介绍01背包的时候会花费较多笔墨，尽量保证大家能够理解01背包，接下来后面的背包问题就会只对于题目相对01背包作出的更改进行讲解。
九大背包问题专题--完全背包问题（详解，最优解）
gl620321的博客
04-28 9711
2.完全背包问题 和01背包问题的区别： 01背包1件物品只能选或者不选 完全背包问题：1件物品可以重复选多次，只要不超过总体积 题目： 问题： 有N件物品和一个容量是V的背包。 第i件物品的体积是vi，价值是wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包的容量，且价值最大。 输入格式 第一行有两个整数，N,V用空格隔开，分别表示物品数量和背包容积。 接下来有N行，每行两个整数vi...
动态规划------背包问题详解
weixin_45102820的博客
08-05 3944
一、01背包 有n件物品，每件物品占用的空间为w[i], 价值为p[i]。 有容量为 V 的背包。求在容量允许的范围下，背包装入物品的最大价值。 在当前为i，v的情况下，考察第i件物品。有两种情况。 1、如果i物品的体积大于v，装不下了。就只能放弃。则最大价值不变。dp[i][v] = dp[i-1][v]; 2、如果i物品的体积不大于v，可以选择装入i或者放弃i。 如果装入i，则剩余的容量变为v-w[i]。整个问题变为，先把i装入，再用v-w[i]的空间去装前i-1件物品。 dp[i][v] = dp[i
背包问题 算法与原理
披风秃头侠的博客
03-14 5958
0-1背包 和 部分背包 关于背包问题，其实可以分为两种类型：0-1背包问题（动态规划） 和 部分背包问题（贪心算法）。 0-1背包问题：每件物品或被带走，或被留下，（需要做出0-1选择）。小偷不能只带走某个物品的一部分或带走两次以上同一个物品。 在选择是否要把一个物品加到背包中，必须把该物品加进去的子问题的解与不取该物品的子问题的解进行比较。这种方式形成的问题导致了许多重叠子问题，满足动态规...
01背包问题动态规划详解
04-03
01背包问题是一个经典的动态规划问题，它的目标是在给定一组物品和一个背包容量的情况下，选择一些物品放入背包中，使得放入背包的物品总价值最大化，同时不能超过背包的容量限制。 具体来说，假设有n个物品，每个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值