动态规划·背包问题

已于 2022-07-10 15:26:28 修改
阅读量562 收藏 2
点赞数 2
文章标签： 动态规划 算法 c++
于 2022-07-10 15:22:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70948728/article/details/125706297
版权

背包问题

一、01背包（每件物品最多只能用一次）

N个物品，容量是V的背包，每个物品体积vi，重量wi，每件物品最多只能用一次。求装进包的最大总价值。

DP问题：

  1. 状态表示 f ( i , j ) f(i,j) f(i,j) （最终所求为 f ( N , V ) f(N,V) f(N,V)）
    1. 集合
      1. 所有选法
      2. 条件
        1. 只从前i个物品中选
        2. 总体积<=j
    2. 属性（最大价值、最小代价、元素数量）
  2. 状态计算——集合的划分
    请添加图片描述

二维

（1）状态f[i][j]定义：前 i i i个物品，背包容量 j j j下的最优解（最大价值）：

当前的状态依赖于之前的状态，可以理解为从初始状态f[0][0] = 0开始决策，有 N 件物品，则需要 N 次决 策，每一次对第 i 件物品的决策，状态f[i][j]不断由之前的状态更新而来。
（2）当前背包容量不够（j < v[i]），没得选，因此前 i 个物品最优解即为前 i − 1 i−1 i−1 个物品最优解：

对应代码：f[i][j] = f[i - 1][j]。
（3）当前背包容量够，可以选，因此需要决策选与不选第 ii 个物品：

选：f[i][j] = f[i - 1][j - v[i]] + w[i]。
不选：f[i][j] = f[i - 1][j] 。
我们的决策是如何取到最大价值，因此以上两种情况取 max() 。

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010;

int n,m;
int v[N],w[N];
int f[N][N];//f[i][j],j体积下前i个物品的最大价值

int main(){
    cin>>n>>m;

    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];

    //给f[][]初始化
    //f[0][0~m]=0 但由于全局变量默认为0，不需单独初始化

    for(int i=1;i<=n;i++)
        for(int j=0;j<=m;j++)
        {
            //当前背包装不下第i个物品
            if(j>=v[i]) f[i][j]=f[i-1][j];
             
            //能装下，需进行决策是否选择第i个物品
            else f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
        }

        cout<<f[n][m]<<endl;

        return 0;
}

一维优化

（1）状态f[j]定义：N 件物品，背包容量j下的最优解。

（2）注意枚举背包容量j必须从m开始，从大到小枚举。

（3）为什么一维情况下枚举背包容量需要逆序？在二维情况下，状态f[i][j]是由上一轮i - 1的状态得来的，f[i][j]与f[i - 1][j]是独立的。而优化到一维后，如果我们还是正序，则有f[较小体积]更新到f[较大体积]，则有可能本应该用第i-1轮的状态却用的是第i轮的状态。

（4）例如，一维状态第i轮对体积为 33 的物品进行决策，则f[7]由f[4]更新而来，这里的f[4]正确应该是f[i - 1][4]，但从小到大枚举j这里的f[4]在第i轮计算却变成了f[i][4]。当逆序枚举背包容量j时，我们求f[7]同样由f[4]更新，但由于是逆序，这里的f[4]还没有在第i轮计算，所以此时实际计算的f[4]仍然是f[i - 1][4]。

所以，状态转移方程为：f[j] = max(f[j], f[j - v[i]] + w[i] 。

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010;

int n,m;
int v[N],w[N];
int f[N];

int main(){
    cin>>n>>m;

    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];

    //给f[][]初始化
    //f[0][0~m]=0 但由于全局变量默认为0，不需单独初始化

    for(int i=1;i<=n;i++)
        for(int j=m;j>=v[i];j--)//从大到小枚举所有体积
        {
            //f[j]=f[j];
            //右边情况不一定存在
            //if(j>=v[i]) 
                f[j]=max(f[j],f[j-v[i]]+w[i]);
                  /*这个式子等价于 f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]),
                  但是应该为f[i-1][j-v[i]]，所以从大到小枚举*/
        }
        cout<<f[m]<<endl;
	    return 0;
}

在一维状态下，少了i件物品这个纬度，用外层for循环，循环到第i轮来表示。f[j]就是指i件物品的条件下背包容量为j下的最大价值。

当循环结束后，外层循环了n次，即到了n件物品，而此时f[j]就是所有物品背包容量j下的最大价值。一维f[j]等价于二维f[n][j]。

优化输入

不必分开记录体积和价值，直接边输入边处理。

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int f[N];

int main() 
{
    cin >> n >> m;

    for(int i = 1; i <= n; i++) {
        int v, w;
        cin >> v >> w;      
        for(int j = m; j >= v; j--)
            f[j] = max(f[j], f[j - v] + w);//读入新数据后即更新f[j]
    }

    cout << f[m] << endl;

    return 0;
}

二、完全背包（每件物品可以用无限次）

朴素做法：

  1. 状态表示：f[i][j]

    1. 集合：所有只考虑前i个物品，且总体积不大于j的所有选法
    2. 属性：Max

  2. 状态计算：集合的划分

    可按照第i个物品选多少个来将f[i][j]划分为若干个集合（0~k个）

请添加图片描述

当k=0，f[i][j]=f[i-1,j]

当取k时：

（1）去掉k个物品i

（2）求Max，f[i-1,j-k*v[i]]

（3）再加回来k个物品i

​ 所以 f[i][j]=f[i-1,j-k*v[i]]+k*w[i]

以上两种情况合并，状态转移方程：f[i,j]=f[i-1,j-v[i*k]+w[i]*k]

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010;
int n,m;
int v[N],w[N];
int f[N][N];

int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    
    for(int i=1;i<=n;i++)//前i个物品
        for(int j=0;j<=m;j++)//总体积不超过j
            for(int k=0;k*v[i]<=j;k++)//枚举第i个物品的个数
                f[i][j]=max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
        
    cout<<f[n][m]<<endl;
    
    return 0;
}

优化

f[i,j]=f[i-1,j-v[i*k]+w[i]*k]

展开，取含0~n个第i个物品的价值最大值：

f[i,j]=Max(f[i-1,j],f[i-1,j-v]+w,f[i-1,j-2v]+2w,f[i-1,j-3v]+3w,...)

再将f[i,j-v]展开

f[i,j-v]=Max( f[i-1.j-v], f[i-1,j-2v]+w, f[i-1,j-3v]+2w,...)

观察两式可发现：

Max(f[i-1,j-v]+w,f[i-1,j-2v]+2w,f[i-1,j-3v]+3w,...)

= Max(f[i-1.j-v],f[i-1,j-2v]+w,f[i-1,j-3v]+2w,...)+w

两式合并可得：

完全背包：f[i,j]=Max(f[i-1,j],f[i,j-v]+w)

(对比01背包：f[i,j]=Max(f[i-1,j],f[i-1,j-v]+w))

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010;
int n,m;
int v[N],w[N];
int f[N][N];

int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    
    for(int i=1;i<=n;i++)//前i个物品
        for(int j=0;j<=m;j++){//总体积不超过j
             f[i][j] = f[i-1][j];
             if(j>=v[i]) f[i][j] = max(f[i][j],f[i][j-v[i]]+w[i]);
        }
            
        
    cout<<f[n][m]<<endl;
    
    return 0;
}

最终优化：

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010;
int n,m;
int v[N],w[N];
int f[N];

int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    
    for(int i=1;i<=n;i++)//前i个物品
        for(int j=v[i];j<=m;j++){//总体积不超过j
             //这里的f[j-v[i]]就是指f[i][j-v[i]]，是同一层，所以不需要倒着枚举
             f[j] = max(f[j],f[j-v[i]]+w[i]);
        }
            
        
    cout<<f[m]<<endl;
    
    return 0;
}

三、多重背包（每种物品数目不同）

朴素写法：

  1. 状态表示f[i,j]
    1. 集合：所有只从前i个物品中选，且总体积不超过j
    2. 属性：Max
  2. 状态计算

按照i类选的个数来划分集合
请添加图片描述

状态转移方程：f[i][j]=max(f[i-1][j-v[i]*k]+w[i]*k);k=0,1,2...s[i]

#include<iostream>
#include<algorithm>
using namespace std;

const int N=110;

int n,m;
int v[N],w[N],s[N];
int f[N][N];

int main(){
    cin>>n>>m;
    
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i]>>s[i];
    
    for(int i=1;i<=n;i++)//从1~n号物品
        for(int j=0;j<=m;j++)//枚举容量
            for(int k=0;k<=s[i]&&k*v[i]<=j;k++)//枚举第i个物品选多少个
                f[i][j]=max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
                
    cout<<f[n][m]<<endl;
}

优化：

f[i,j]  = max(f[i-1,j],f[i-1,j-v]+w,f[i-1,j-2v]+2w,...,f[i-1,j-sv]+sw)
f[i,j-v]=max(          f[i-1,j-v],  f[i-1,j-2v]+w,..,  f[i-1,j-sv]+(s-1)w,f[i-1,j-(s+1v)]+sw)
//根据上两式无法直接求出，故无法用完全背包的优化方式直接优化

这里使用二进制的优化方式

例如：s=1023
    将其按照1，2，4，8，512划分
    即把s划分为若干组，每组最多只能选一次（类似于01背包）
    则可以用这些划分表示出0~1023任意数字
原本需要枚举1024次，现只需枚举10次

再如s=200
1，2，4，8，16，32，64  这些可拼凑出0~127
    故再补一个73即可拼凑出0~200

从特殊到一般：
若给出一个一般的s
    1,2,4,8,...,2^k,c   显然有c<2^(k+1)
    1,2,4,8,...,2^k可拼凑出0~2^(k+1)-1种的任意一个数
    加上c可拼凑出c~s种的任意一个数
    因为c<2^(k+1)，所有以上两个区间合并后为[0,s]

s -> logs
时间复杂度：从NVS优化为NVlogS

有 N 种物品和一个容量是 V 的背包。

第 ii 种物品最多有 si 件，每件体积是vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式

第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式

输出一个整数，表示最大价值。

数据范围

0<N≤1000
0<V≤2000
0<vi,wi,si≤2000

提示：

本题考查多重背包的二进制优化方法。

输入样例

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

#include<iostream>
#include<algorithm>
using namespace std;

const int N=25000,M=2010;

int n,m;
int v[N],w[N];
int f[N];

int main(){
    cin>>n>>m;
    int cnt=0;//划分出来的数字个数
    for(int i=1;i<=n;i++){
        int a,b,s;
        cin>>a>>b>>s;
        int k=1;//每个划分的数
        while(k<=s){//当s还可以继续划分
            cnt++;
            v[cnt]=a*k;//这个划分的总体积
            w[cnt]=b*k;//这个划分的总质量
            s-=k;
            k*=2;//是2的乘方
        }
        if(s>0){//如果s无法被2的次方整分，仍有剩余，此时剩下的这个s相当于最后补上的c
            cnt++;
            v[cnt]=a*s;
            w[cnt]=b*s;
        }
    }
    
    n=cnt;//划分之后一共cnt组，即相当于01背包一共n个物品
    //即把这些打包，最终看作01背包
    
    //转化成了01背包
    for(int i=1;i<=n;i++)
        for(int j=m;j>=v[i];j--)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
            
    cout<<f[m]<<endl;
    
    return 0;
}

四、分组背包（n组物品，每组里最多只能选一个）

  1. 状态表示 f[i,j]

    1. 集合：所有只从前i个物品中选，且总体积不超过j
    2. 属性：集合中所有选法中的价值的最大值

  2. 状态计算

    枚举第i组物品选哪个or不选

请添加图片描述

#include<iostream>
#include<algorithm>
using namespace std;

const int N=110;

int n,m;
int v[N][N],w[N][N],s[N];
int f[N];

int main(){
    cin>>n>>m;
    
    for(int i=1;i<=n;i++){
        cin>>s[i];
        for(int j=0;j<s[i];j++)
            cin>>v[i][j]>>w[i][j];
    }
    
    //状态转移时，如果用的有上一层的数据，则从大到小枚举，如果用的都是本层的，则从小到大枚举
    for(int i=1;i<=n;i++)//枚举1~n组
        for (int j = m; j >= 0; j -- )//先枚举体积，倒着枚举这样就不会被自己更新
            for(int k=0;k<s[i];k++)//枚举第i组中的s[i]个物品
                //这里与其他01背包有些不同，因为在枚举j的时候还没有枚举每一个数，故需特判
                if(v[i][k]<=j)//这个物品体积足够小，可以选
                    f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);
    cout<<f[m]<<endl;
    
    return 0;
}

参考：
https://www.acwing.com/solution/content/1374/

祁姻
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
背包问题 动态规划
m0_53203911的博客
03-31 6138
背包问题核心 优化一般就是优化状态转移方程 01背包问题 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0
动态规划专题——背包问题
热门推荐
⚡
02-13 4万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
动态规划——背包问题
Ten_years_star的博客
08-17 2684
对于背包问题，今天我们先讲解，01背包，完全背包，和多重背包。
【动态规划】背包问题 {01背包问题；完全背包问题；二维费用背包问题}
最新发布
芥末虾的博客
07-15 1282
【动态规划】背包问题 {01背包问题；完全背包问题；二维费用背包问题}
动态规划之背包问题
sevenStar_1的博客
03-27 901
背包问题是一类经典的动态规划算法题 背包问题有以下几类 1. 01背包问题 最基本的背包问题就是01背包问题（01 knapsack problem）：一共有N件物品，第i（i从1开始）件物品的重量为w[i]，价值为v[i]。在总重量不超过背包承载上限W的情况下，能够装入背包的最大价值是多少？ 01背包问题的解决思路是： 定义dp[i][j]为当前背包容量为j时前i个物品组合能装入背包的最大价值 0<=i<=N, 0<=j<=W 也就是说我们可以将 dp[0][0…W] 初始化为
《背包问题》 动态规划
weixin_34413103的博客
05-28 133
问题描述： 一切都要从一则故事说起。 话说有一哥们去森林里玩发现了一堆宝石，他数了数，一共有n个。 但他身上能装宝石的就只有一个背包，背包的容量为C。这哥们把n个宝石排成一排并编上号： 0,1,2,…,n-1。第i个宝石对应的体积和价值分别为V[i]和W[i] 。排好后这哥们开始思考： 背包总共也就只能装下体积为C的东西，那我要装下哪些宝石才能让我获得最大的利益呢？ 思路...
动态规划-背包问题
weixin_41082481的博客
04-21 8065
动态规划 动态规划（Dynamic Programming，简称DP）动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。 动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。 通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量： 一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。 这种做法在重复子问题的数目关于输入的规模
动态规划背包问题6篇讲解+源码
03-29
动态规划是解决背包问题的一种经典方法，它通过将原问题分解为子问题，并保存子问题的解来避免重复计算，从而优化算法的效率。背包问题通常涉及一系列物品，每个物品有各自的重量和价值，目标是在不超过背包总重量的...
python动态规划背包问题算法-01背包问题（动态规划算法）.pdf
05-01
01背包问题是一种经典的动态规划问题，主要应用于优化资源分配以获取最大效益。在这个问题中，我们有N种物品，每种物品有一个固定的体积wi和对应的价值ci，还有一个总容量为V的背包。目标是在不超过背包容量的情况下...
动态规划法求解0-1背包问题实验报告.pdf
06-05
0-1背包问题是一个经典的优化问题，主要涉及动态规划算法的运用。在这个实验报告中，学生使用Java语言解决了一个0-1背包问题的实例。以下是关于这个问题和解决方案的详细解释。 一、问题描述： 0-1背包问题的核心是...
Python基于动态规划算法解决01背包问题实例
12-25
本文实例讲述了Python基于动态规划算法解决01背包问题。分享给大家供大家参考，具体如下： 在01背包问题中，在选择是否要把一个物品加到背包中，必须把该物品加进去的子问题的解与不取该物品的子问题的解进行比较，...
动态规划求解背包问题
饮血太岁的博客
01-13 371
动态规划求解背包问题，并用c#实现
【动态规划】—— 背包问题
forever_bryant的博客
06-26 287
【动态规划】—— 背包问题
动态规划背包问题详解：九讲实战指南
本教程深入探讨了动态规划中的核心问题——背包问题，共计九个章节，旨在为具有一定算法基础的读者提供详尽的学习指南。从基础的01背包问题（即每个物品只能取一次）开始，逐级讲解了完全背包问题（每个物品可以取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值