背包问题整理

已于 2022-02-12 17:48:17 修改
阅读量609 收藏
点赞数
分类专栏： 动态规划 文章标签： c++ 算法 动态规划
于 2022-01-29 20:48:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45895217/article/details/122747272
版权

文章目录

01背包问题

朴素算法

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 1e3+10;
int v[N];   //价值
int w[N];   //重量
int f[N][N]; //考虑前i个物品，背包容量为j时的最大价值
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        cin>>w[i]>>v[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            f[i][j] = f[i-1][j];
            if(j >= w[i])
            f[i][j] = max(f[i-1][j],f[i-1][j-w[i]] + v[i]);
        }
    }
 
    cout<<f[n][m];
}

一维优化

f[i][j]代表前i个物品 背包容量为j时的最大价值。
所以每读入一个价值 体积 就开始第二层即可。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int f[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i = 1;i <= n; i ++)
    {
        int w,v;    //分别代表物品的体积 价值
        cin>>w>>v;
        for(int j = m;j >= w; j--)
            f[j] = max(f[j], f[j - w] + v);
    }
    cout<<f[m];
}

完全背包问题

每个物品用无数次

二维朴素算法

01背包问题中，第二层循环倒着的原因是
f[i][j] = max(f[i-1][j], f[i-1][j-w[i]+v[i])
计算f[i][j]时,需要用到f[i-1][j-w[i]]
优化成一维时，f[j-w[i]]在f]j]前面
所以如果从前往后循环，用的就是更新后的f[j-w[i]]即f[i][j-w[i]]而不是f[i-1][j-w[i]]，也就是第i个物品用了多次。为了防止这种情况，01背包第二层循环倒过来

而完全背包正好迎合这种思想，故直接从前往后循环即可。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int f[N][N];
int v[N],w[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>w[i]>>v[i];
    for(int i=1;i<=n;i++)
        for(int j=0;j<=m;j++)
            {
                f[i][j] = f[i-1][j];
                if(j >= w[i])
                f[i][j] = max(f[i-1][j], f[i][j - w[i]] + v[i]);
            }

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

一维优化

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int f[N];
int v[N],w[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>w[i]>>v[i];
    for(int i=1;i<=n;i++)
        for(int j=w[i];j<=m;j++)
            {
               f[j] = max(f[j], f[j-w[i]] + v[i]);
            }

    cout<<f[m];
}

多重背包问题I

最简单 直接三重for循环
第三层循环循环选0~s[i]个物品 //s[i]表示第i个物品的最大数量

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

多重背包问题II

题解

数据范围上升至1e3, 3重for循环会109，故需要优化

二进制优化

结合自己的笔记看

如何将一个数x合理的划分为二进制数，使这些数可以表示 0~x 之间的任意一个数

对 10 而言
1 2 4 3 是合理的划分
对 12而言
1 2 4 5 是合理的划分
然后转化为01背包问题

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

struct Good
{
    int v,w;
};
vector<Good> goods;
int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
    {
        int v,w,s;
        cin >> v >> w >> s;
        for(int k = 1; k <= s; k *= 2)
        {
            s -= k;
            goods.push_back({v * k , w * k});
        }
        if(s > 0)
            goods.push_back({v * s , w * s});
    }
    for(int i = 0 ; i < goods.size() ; i ++ )
    {
        for(int j = m ; j >= goods[i].v ;j --)
        {
            f[j] = max(f[j] , f[j - goods[i] . v ] + goods[i] . w);
        }
    }
    cout<<f[m];
}

多重背包问题III

题解

需要用到单调队列优化。类似优先队列。
不太会，他也没大讲

混合背包问题

既有01背包只能用1次的 也有完全背包用无限次的 也有多重背包有个数限制的。
将多重背包的二进制转化为01背包。
所以只有01背包和完全背包的。
二者的区别在于01背包第二层for循环倒着，完全背包的第二层for循环正着，分开讨论

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 1010;
int f[N];
struct thing
{
    int kind;
    int v,w;
};
vector <thing> things;

int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int w,v,s;
        cin>>w>>v>>s;
        if(s == -1)
            things.push_back({-1,v,w});
        else if(s == 0)
            things.push_back({0,v,w});
        else    //说明是多重背包问题
        {
            for(int k = 1; k <= s; k*=2)
            {
                s -= k;
                things.push_back({-1, k * v, k * w});
            }
            if(s > 0) things.push_back({-1, s * v, s * w});
        }
    }   
    
    //01 和完全背包分开
    for(int i = 0; i< things.size(); i++)
    {
        int kind = things[i].kind, v = things[i].v , w = things[i].w;
        if(kind == -1)
        {
             for(int j = m; j >= things[i].w; j--)  //如果是01背包就从大到小枚举
                f[j] = max(f[j],f[j - w] + v);
        }
        else
        {
            for(int j = w; j <= m;j ++)             //如果是完全背包就从小到大枚举               
            	f[j] = max(f[j],f[j - w] + v);
        }
    }
    cout<<f[m];
}

二维费用的背包问题

与01背包相比，既有体积限制，又有重量限制
f[i][j]表示背包体积为 i 最大承重为 j 情况下的能放的最大价值

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int f[N][N]; //f[i][j] 表示 背包体积为i 承重为j的情况下的最大价值
int main()
{
    int n,V,M;
    cin>>n>>V>>M;
    for(int i=1;i<=n;i++)
    {
        int v,m,w;//分别代表体积 重量 价值
        cin>>v>>m>>w;
        for(int j = V; j >= v; j--)     //从大到小枚举
            for(int k = M; k >= m; k--) //从大到小枚举
                f[j][k] = max(f[j][k], f[j - v][k - m] + w);
    }
    cout<<f[V][M];
}

分组背包问题

有多个组，每个组内选1个最多。
数据范围很小 只有100 可以用O(n3)
是朴素多重背包算法的一般情况，代码很像

//是多重背包的一般情况。和多重背包代码很像很像
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 110;
int f[N];
int v[N],w[N];//分别表示价值 体积

int main()
{
    int n,m;//分别表示n组物品 背包容量为m
    cin>>n>>m;
    
    for(int i=1;i<=n;i++)
    {
        int s;  //表示每组中物品的个数  每输入一组接着求出来对于该组的方案
        cin>>s;
        for(int j = 1;j <= s;j++)
        {
            cin>>w[j]>>v[j];
        }
        for(int j = m; j >= 0; j--)
            for(int k = 1; k <= s;k++)  
            {
                if(j - w[k] >= 0)
                f[j] = max(f[j], f[j - w[k]] + v[k]);   //需要用到前面的f[j - w[k]] 所以j从后往前更新
            }
    }
    cout<<f[m];
}

背包问题求方案数

需要很好的理解 什么是 状态转移
看f[i][j] 是从f[i-1][j]转移过来还是f[i-1][j-w[i]]+v[i]转移而来

/*
不能用自己最早的想法，先求一遍，求出f[n][m]，再去重新求一遍，看看有多少个数 = f[n][m]
因为虽然数可能是一样的，但可能始终是一个方案，选的是同一组物品，只不过没有比他更大的，一直就是他延续下去的。
还是要看方案数，选不同的物品。
*/
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
const int MOD = 1e9+7;
const int INF = 0x3f3f3f3f;
int n,m; 
int f[N];   //f[i] 放入物品体积恰好为i情况下的最大价值
int g[N];   //g[i] 放入物品体积恰好为i的情况下的最大方案数是多少
int v[N],w[N];  //分别表示价值 体积
/*
f[i]表示体积恰好为i的情况下的最大价值 的原因：
因为01背包问题中，f[i]表示体积不超过i的情况下的最大价值，包含了0~i
因为这里是计数，所以 每个表示不同体积的 都要分开，要不会有重复
*/
int main()
{
    cin>>n>>m;
    g[0] = 1; //体积为0表示啥也不放 方案数为 1
    for(int i=1;i<N;i++) f[i] = -INF;

    for(int i=1;i<=n;i++)
    {
        int w,v;
        cin>>w>>v;
        for(int j = m; j >= w; j--)
        {
            int t = max(f[j],f[j-w] + v);
            int s = 0;
            if(t==f[j]) s+=g[j];
            if(t==f[j-w] + v) s+=g[j-w];
            s%=MOD;
            f[j] =t;
            g[j] = s;
        }
    }
    //f[m]表示体积恰好为m情况下的最大价值 但是不一定代表体积小于等于m的情况 所以需要求出最大价值
    int max_value = 0;
    for(int i=1;i<=m;i++) max_value = max(max_value, f[i]);
    int res = 0;
    for(int i=0;i<=m;i++)
        if(f[i] == max_value)
            res = (res + g[i]) % MOD;
    cout<<res;
}

背包问题求具体方案

题解

求dp的时候倒着，求方案的时候正着，然后如果前面和后面相等则输出前面的即代表字典序最小的。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int f[N][N];
int v[N],w[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>w[i]>>v[i];
    }
    for(int i=n;i;i--)  //从后往前 写dp 可以从前往后找方案，这样后面比前面大就可以直接输出前面
    {
        for(int j=0;j<=m;j++)
        {
            f[i][j] = f[i+1][j];
            if(j >= w[i])
                f[i][j] = max(f[i+1][j], f[i+1][j - w[i]] + v[i]);
        }
    }
    
    int i=1,j=m;
    while(i <= n)
    {
        if(j >= w[i] && f[i+1][j - w[i]] + v[i] >= f[i+1][j]) //if(j >= w[i] && f[i+1][j - w[i]] + v[i] == f[i][j])
        {
            printf("%d ",i);
            j -= w[i];
            i ++;
        }
        else i++;
    }
}
小菜0-o
关注
专栏目录
动态规划——背包问题整理（01背包+完全背包）
weixin_50666824的博客
02-15 7058
1、引言 背包问题简单描述，其实就是有一堆物品同时具有一定价值和重量，现有一个背包可以承受最大重量m，那么要怎么选择在不超过背包最大重量的前提下，使背包中选择的物品价值最大。 最常见的背包问题又可以分为：01背包和完全背包，图示如下： （图片引自：代码随想录） 2、标准01背包分析 （1）问题描述 （2）分析 最直接的想法应该是暴力解法，每一件物品只存在两种状态，拿或者不拿，那么便可以采用回溯的思想例举出所有可能，然后找到价值最大的组合，但我们会发现时间复杂度就到了...
【动态规划】 背包问题整理
findover的博客
09-28 243
【动态规划】 背包问题整理 背包问题01 题目类型描述： 给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高（from 百度百科）。 具象理解： 假设背包总容量top_weight为10，现共有四样物品（每样各一个），他们的重量和价格分别为： 当我们直观看到这幅表的时候基本可以确定我们会选择1，2，4号物品，这样可以最大程度地装载物品且使利润最...
背包问题( LevOJ P1306 )
孤独的饺子的博客
12-11 767
首先，我还是要先啰嗦一下背包问题的题外话。 动态规划（dp）是求解决策过程最优化的数学方法，其过程大概如下：为了寻求最优解，我们可以把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解。 咳咳，不啰嗦了，步入正题。 背包问题最基本的分为三大类：0-1背包，完全背包和多重背包。 我先稍微解释一下三种背包的大概意思。0-1背包是指往背包里装入的物品每种只有一件，完全背包则是往背包...
0-1背包问题zZ
FUN6367的博客
05-09 368
问题描述： 有n件物品，每件物品的重量为w[i]，其价值为v[i]，现在有个容量为m的背包，如何选择物品使得转入背包物品的价值最大。 思路: 首先想到的肯定是枚举所有物品的排列组合，再从中找到价值最大的那个组合，时间复杂度O(n!)。同样可以通过选择是否需要某个物品来枚举出所有的排列组合，时间复杂度O(2^n)。这样的时间复杂度是完全不能接受的 采用动态规划的方法，时间复杂度只有O(nm)，具体方法如下: 首先设置一个二维数组dp[][]，令dp[i][j]表示前i个物品装进容量为j的背包能获得的
顺丰小哥派件装载问题——典型的01背包问题
qq_57328462的博客
06-22 639
题目：比赛的时候没看这一题- -！！没想到竟然是一个典型的01背包问题，早知道这样我早写这题就好了，我真的栓Q了。思路：与背包问题对比：所以，发现，两者问题没有丝毫差别，还等什么？直接肝啊！*1* dp数组含义：dp[i]表示当装入 体积 为 i 的快递后，快递箱中快递能得到的最大容量；*2* 递推公式：两种情况，装还是不装，选择其中最大值：dp[i]=max(dp[i],dp[i-N[j]]+N[j]);*3* 初始化：dp[0]=0;*4* 遍历顺序；*5* 打印dp注意：dp写法一般有两种，分为二维d
一道美团面试题(背包问题)的两种思路
qq_40592484的博客
10-30 735
大家好,用CSDN很多年了,一直在吸取养分,很感激.今天心血来潮,咱也贡献一个. 01 一道面试题 从n个商品中,选择一些物品使其在不大于背包容量时价值最大. 001 动态规划法 下面是代码 总体上来讲,动态规划就是找最优子结构, 假设已经找到了选出物品的最佳组合,那么被选中的商品中去掉一个,这一个被去掉的商品 同样的在可选择商品中也去掉,那么只要现在去掉之后的商品组合任然满足在可选商品中 是价值...
为什么01背包要倒着推，完全背包要顺着推
11-04 765
为什么01背包要倒着推，完全背包要顺着推 我忽然发现，这个小学的知识点，额，一直没有弄懂。现在赶快总结一下。 01背包每个物品只能选一次，所以若用\(f[i][v]\)表示前i件物品，恰好放入一个容量为v的背包可获得的最大价值，那么其二维状态转移方程是：\(f[i][v]=max(f[i-1][v], f[i-1][v-c[i]]+w[i])\)。注意是恰好，所以最后还要max一下。也可...
背包问题（整理）
ZhangyiA的博客
12-03 142
在这里推荐一些，关于背包九讲，非常好的视频讲解和相关的博客学习 背包九讲 —— yxc 直播回放   B站 大雪菜 背包九讲 —— 全篇详细理解与代码实现   CSDN 良月澪二，博主提供了很多背包方面的题解。 结合视频和博客的学习，这里提供一些 java 的实现版本，其实就是翻译一下，大佬们的 C++ 程序 。 这些题都可以在 AcWing 题库第一页就能找到，是不是很方便。 这里也只介绍了四类背包问题， 因为其他的类型，本人太菜了，还没学会 ( T—T ) ， 后期再慢慢加上。 01背包 传送门 i
【动态规划】背包问题的几种变形
he_Microsoft的博客
05-15 623
1，最小划分 LintCode 炼码 给出一个正整数数组，写一个程序把这个整数数组分成S1跟S2两部分，使S1中的和跟S2中的和的差的绝对值最小。换句话讲，如果有一个一个整数数组 S 有 n 个数，如果Subset1有 m 个数，Subset2必须有 n-m 个数并且 abs(sum(Subset1) – sum(Subset2)) 应该最小。 #x,sum-x #sum-x-x最小 #x最接近sum/2 #转换成01背包sum/2就.
动态规划：一篇文章带你搞定背包型问题
BudingCode的博客
03-15 862
最常见的动态规划-01背包
外卖（动态规划-背包DP）
SOUIC的博客
05-25 1026
外卖（动态规划-背包DP） 题目描述 Bob 是一个重度外卖依赖者。这天他挑中了一家店，这家店总共有 n 种菜品，每种菜品限点一份，需要满 m 元钱才可配送，因此 Bob 想知道他至少需要花多少钱才能满足最低配送要求。 输入 输入共两行，第一行为两个正整数，n 和 m，第二行为 n 个正整数 ai 输出 输出一个数，满足最低配送要求所花的最少钱数。 样例输入 【样例1】 3 10 3 7 9 【样例2】 5 12 10 11 7 8 9 【样例3】 3 8 1 6 9 样例...
头哥算法答案及解析
热门推荐
m0_51930376的博客
03-04 1万+
目录实验1第1关：数字统计问题第2关：字典序第3关：兔子问题(求斐波那契数列前200项)实验二 实验1 第1关：数字统计问题 本关任务：一本书的页码从自然数1开始编码直到自然数n。书的页码按照通常的习惯编排，每个页码都不含多余的前导数字0. 例如，第8页用数字8表示，而不是08或者008之类。 数字统计问题要求对给定书的总页码n，计算出书的全部页码中分别出现了多少次数字0，1，2，…,9。 #include<stdio.h> #include<math.h> #include<
简单0-1背包问题
梧桐下的四叶草
02-02 1384
题目描述 有一个背包能装的重量maxw(正整数，0≤maxw≤20000)，同时有n件物品(0≤n≤100)，每件物品有一个重量wi(正整数)和一个价值pi(正整数)。要求从这n件物品中任取若干件装入背包内，使背包的物品价值最大。 输入 第1行：背包最大载重maxv，物品总数n 第2行到第n+1行：每个物品的重量和价值 输出 一个数字即背包内物品最大价值 样
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 533
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
OpenGL Texture C++ Camera Filter滤镜视频录制
最新发布
wangyongyao1989的博客
10-19 569
​ OpenGL Texture C++ Camera Filter滤镜视频录制; 基于文章1/2/3的代码，结合Google开源项目grafika中的WindowSurface.java/Coregl.java/TextureMovieEncoder2.java/VideoEncoderCore.java创建出录制视频的surface并根据此切换GLContext上下文交换（swapBuffer）渲染与显示的视频数据，最终在VideoEncoderCore中通过MediaCodec获取出encodeDat
C++中的vector介绍（常用函数）
zxybf_的博客
10-15 790
vector的文档介绍vector是序列容器，表示可以改变大小的数组。(constructor)构造函数声明接口说明vector()（重点）无参构造构造并初始化n个val（重点）拷贝构造使用迭代器进行初始化构造int main()//无参的构造//n个val的构造//拷贝构造//迭代器区间构造return 0;
第一节、C语言概览
lopowh的博客
10-13 306
C语言中格式化输出函数为printf（），它用来输出数据到计算机屏幕或文件中。程序语言一般都是由关键字，标识符和其他语法单位组成。Printf("，")；Scanf("",)用来从标准输入设备（键盘）读取输入的信息。
【C++】使用 yaml-cpp 库操作 YAML
coco的专栏
10-16 862
配置文件有利于我们灵活配置工程，解决大量重复劳动，也方便调试。YAML 是一种人类可读的数据序列化格式，它使用缩进和特定的符号来表示数据结构。在本文中，我们将详细介绍如何在 C++ 中使用yaml-cpp库来解析和生成 YAML 格式的数据。
Canmv k230 C++案例1.2——image classify项目 C++代码分析（待完成）
stoat04的博客
10-16 217
这部分为初学，所以手头最好有本工具书便于查阅。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值