单调队列多重背包时间复杂度O(vn)
版权声明:本文为博主原创文章,未经博主允许不得转载。
多重背包问题:
有N种物品和容量为V的背包,若第i种物品,容量为v[i],价值为w[i],共有n[i]件。怎样装才能使背包内的物品总价值最大?
网上关于“多重背包”的资料倒是不少,但是关于怎么实现O(N*V)算法的资料,真得好少呀,关于“单调队列”那部分算法,又没说明得很清楚,看了几遍没看懂原理,只好自己动脑去想怎么实现O(N*V)算法。
若用F[i][j]表示对容量为j的背包,处理完前i种物品后,背包内物品可达到的最大总价值,并记m[i] = min(n[i], j / v[i])。放入背包的第i种物品的数目可以是:0、1、2……,可得:
F[i][j] = max { F[i - 1] [j – k * v[i] ] + k * w[i] } (0 <= k <= m[i]) ㈠
如何在O(1)时间内求出F[i][j]呢?
先看一个例子:取m[i] = 2, v[i] = v, w[i] = w, V > 9 * v,
并假设 f(j) = F[i - 1][j],观察公式右边要求最大值的几项:
j = 6*v: f(6*v)、f(5*v)+w、f(4*v)+2*w 这三个中的最大值
j = 5*v: f(5*v)、f(4*v)+w、f(3*v)+2*w 这三个中的最大值
j = 4*v: f(4*v)、f(3*v)+w、f(2*v)+2*w 这三个中的最大值
显然,公式㈠右边求最大值的几项随j值改变而改变,但如果将j = 6*v时,每项减去6*w,j=5*v时,每项减去5*w,j=4*v时,每项减去4*w,就得到:
j = 6*v: f(6*v)-6*w、f(5*v)-5*w、f(4*v)-4*w 这三个中的最大值
j = 5*v: f(5*v)-5*w、f(4*v)-4*w、f(3*v)-3*w 这三个中的最大值
j = 4*v: f(4*v)-4*w、f(3*v)-3*w、f(2*v)-2*w 这三个中的最大值
很明显,要求最大值的那些项,有很多重复。
根据这个思路,可以对原来的公式进行如下调整:
假设d = v[i],a = j / d,b = j % d,即 j = a * d + b,代入公式㈠,并用k替换a - k得:
F[i][j] = max { F[i - 1] [b + k * d] - k * w[i] } + a * w[i] (a – m[i] <= k <= a) ㈡
对F[i - 1][y] (y= b b+d b+2d b+3d b+4d b+5d b+6d … j)
F[i][j]就是求j的前面m[i] + 1个数对应的F[i - 1] [b + k * d] - k * w[i]的最大值,加上a * w[i],如果将F[i][j]前面所有的F[i - 1][b + k * d] – k * w放入到一个队列,那么,F[i][j]就是求这个队列最大长度为m[i] + 1时,队列中元素的最大值,加上a * w[i]。因而原问题可以转化为:O(1)时间内求一个队列的最大值。
该问题可以这样解决:
① 用另一个队列B记录指定队列的最大值(或者记录最大值的地址),并通过下面两个操作保证队列B的第一个元素(或其所指向的元素)一定是指定队列的当前最大值。
② 当指定队列有元素M进入时,删除队列B中的比M小的(或队列B中所指向的元素小等于M的)所有元素,并将元素M(或其地址)存入队列B。
③ 当指定队列有元素M离开时,队列B中的第一个元素若与M相等(或队列B第一个元素的地址与M相等),则队列B的第一个元素也离队。
经过上述处理,可以保证队列B中的第一个元素(或其指向的元素)一定是所指定队列所有元素的最大值。显然队列B的元素(或其所指向的元素)是单调递减的,这应该就是《背包九讲》中的提到的“单调队列”吧,初看的时候被这个概念弄得稀里糊涂,网上的资料提到“维护队列的最大值”,刚开始还以为是维护这个单调队列的最大值,对其采用的算法,越看越糊涂。其实,只要明白用一个“辅助队列”,求另一个队列的最值,那么具体的算法,和该“辅助队列”的性质(单调变化),都很容易推导出来。
在多重背包问题中,所有要进入队列的元素个数的上限值是已知的,可以直接用一个大数组模拟队列。
“多重背包”通用模板:
- //“多重背包”通用模板
- const int MAX_V = 100004;
- //v、n、w:当前所处理的这类物品的体积、个数、价值
- //V:背包体积, MAX_V:背包的体积上限值
- //f[i]:体积为i的背包装前几种物品,能达到的价值上限。
- inline void pack(int f[], int V, int v, int n, int w)
- {
- if (n == 0 || v == 0) return;
- if (n == 1) { //01背包
- for (int i = V; i >= v; --i)
- if (f[i] < f[i - v] + w) f[i] = f[i - v] + w;
- return;
- }
- if (n * v >= V - v + 1) { //完全背包(n >= V / v)
- for (int i = v; i <= V; ++i)
- if (f[i] < f[i - v] + w) f[i] = f[i - v] + w;
- return;
- }
- int va[MAX_V], vb[MAX_V]; //va/vb: 主/辅助队列
- for (int j = 0; j < v; ++j) { //多重背包
- int *pb = va, *pe = va - 1; //pb/pe分别指向队列首/末元素
- int *qb = vb, *qe = vb - 1; //qb/qe分别指向辅助队列首/末元素
- for (int k = j, i = 0; k <= V; k += v, ++i) {
- if (pe == pb + n) { //若队列大小达到指定值,第一个元素X出队。
- if (*pb == *qb) ++qb; //若辅助队列第一个元素等于X,该元素也出队。
- ++pb;
- }
- int tt = f[k] - i * w;
- *++pe = tt; //元素X进队
- //删除辅助队列所有小于X的元素,qb到qe单调递减,也可以用二分法
- while (qe >= qb && *qe < tt) --qe;
- *++qe = tt; //元素X也存放入辅助队列
- f[k] = *qb + i * w; //辅助队列首元素恒为指定队列所有元素的最大值
- }
- }
- }
多重背包特例:物品价值和体积相等(w = v)
由于w = v,上面的代码可进行如下修改:
入队的元素: tt = f[k] - (k / v) * w = f[k] - (k - j) = f[k] - k + j
返回的最大值:*qb + (k / v) * w = *qb + k - j
由于j是定值,可调整入队的元素为: f[k] - k,最大值为 *qb + k
但这种做法相当低效。实际上,这相当于一个“覆盖”问题:在放入前i个物品后,体积为j的背包,只存在两种状态:是否能刚好装满,也就是,是否能被覆盖。因而只要记录下该状态就可以了,前面的分析进行相应的调整:
对F[i - 1][y] (y= b b+d b+2d b+3d b+4d b+5d b+6d … j)
F[i][j]就是求j的前面m[i] + 1个数对应的F[i - 1] [b + k * d](其值为0或1)的最大值,即j前面的m[i] + 1个0、1数据中是否存在1,这又可以简化为判断它们的和是否不等于0。
- //pack-01
- const int MAX_V = 100004;
- //w = v 特例
- inline void pack(bool f[], int V, int v, int n)
- {
- if (n == 0 || v == 0) return;
- if (n == 1) { //01背包
- for (int i = V; i - v >= 0; --i)
- if (! f[i] && f[i - v]) f[i] = true;
- //if (f[i - v]) f[i] = true;
- return;
- }
- if (n * v >= V - v + 1) { //完全背包 n >= V / v
- for (int i = v; i <= V; ++i)
- if (! f[i] && f[i - v]) f[i] = true;
- //if (f[i - v]) f[i] = true;
- return;
- }
- bool va[MAX_V];
- for (int j = 0; j < v; ++j) { //多重背包
- bool *pb = va, *pe = va - 1;
- size_t sum = 0;
- for (int k = j; k <= V; k += v) {
- if (pe == pb + n) sum -= *pb++; //队列已满,队首元素出队
- *++pe = f[k]; //进队
- sum += f[k];
- if (! f[k] && sum != 0) f[k] = true;
- //f[k] = (bool)sum;
- }
- }
- }
另外,可以倒着读数据,这样就不需要额外使用一个数组存放临时数据:
- //pack-02
- //w = v 特例
- inline void pack(bool f[], int V, int v, int n)
- {
- if (n == 0 || v == 0) return;
- if (n == 1) { //01背包
- for (int i = V; i - v >= 0; --i)
- if (! f[i] && f[i - v]) f[i] = true;
- //if (f[i - v]) f[i] = true;
- return;
- }
- if (n * v >= V - v + 1) { //完全背包 n >= V / v
- for (int i = v; i <= V; ++i)
- if (! f[i] && f[i - v]) f[i] = true;
- //if (f[i - v]) f[i] = true;
- return;
- }
- for (int j = 0; j < v; ++j) { //多重背包
- int k = V - j, sum = 0;
- //前n + 1个元素入队,前面的判断可以保证: V - j - n * v > 0
- for (; k >= std::max(0, V - j - n * v); k -= v) sum += f[k];
- for (int i = V - j; i > 0; k -= v, i -= v) {
- if (f[i]) --sum; //出队: sum -= f[i]
- else if (sum != 0) f[i] = true;
- //int tt = f[i]; f[i] = (bool)sum; sum -= tt;
- if (k >= 0) sum += f[k];
- }
- }
- }
前面的代码,都在循环中对队列的元素个数进行判断,这可以通过下面的方法避免,将循环拆分成两部分:一部分都有入队和出队操作、另一部分只有入队(或出队)操作。
对该特例,还有一种O(N * V)解法:用一个数组记录当前物品已经使用数,关键代码:
if (! f[i] && f[i - v] && count[i - v] < n)
f[i] = true, count[i] = count[i - v] + 1;
每计算一类物品,count数组都要初始化一次,比较费时,可以再用一个数组记录上一次处理的物品编号,通过判断上一次放入那一类的物品编号与当前这类物品编号是否一致(不一致时,相当于count[i]值为0的情况),从而避免对count数组的初始化操作。还可以将初始化count数组和后面的循环整合在一起。
- //pack-1
- for (int i = 0; i <= V; ++i) count[i] = 0;
- for (int i = v; i <= V; ++i) { //多重背包
- if (! f[i] && f[i - v] && count[i - v] < n) {
- count[i] = count[i - v] + 1;
- f[i] = true;
- }
- }
- //pack-2 cur为当前这类物品的编号
- for (int i = v; i <= V; ++i) { //多重背包
- if (! f[i] && f[i - v]) {
- if (last[i - v] != cur) count[i] = 1, last[i] = cur, f[i] = true;
- else if (count[i - v] < n) {
- count[i] = count[i - v] + 1;
- last[i] = cur;
- f[i] = true;
- }
- }
- }
- //pack-4
- for (int i = v; i <= V; ++i) { //多重背包
- if (f[i]) count[i] = 0;
- else if (f[i - v]) {
- if (i < 2 * v) count[i] = 1, f[i] = true;
- else if (count[i - v] < n) {
- count[i] = count[i - v] + 1;
- f[i] = true;
- }
- }
- }
POJ 1742:有若干不同面值的纸币,问能组合出1到m中的几种面值?
- //poj1742
- #include<algorithm>
- #include<cstdio>
- #define AB 0
- //MAX_N 物品种类数最大值 MAX_n每种物品数目的最大值,MAX_V背包体积最大值
- const int MAX_N = 101, MAX_V = 100004;
- //w = v特例
- inline void pack(bool f[], int V, int v, int n, int& total)
- {
- //if (n == 0 || v == 0) return;
- if (n == 1) { //01背包
- for (int i = V; i - v >= 0; --i)
- if (! f[i] && f[i - v]) f[i] = true, ++total;
- return;
- }
- if (n * v >= V - v + 1) { //完全背包 n >= V / v
- for (int i = v; i <= V; ++i)
- if (! f[i] && f[i - v]) f[i] = true, ++total;
- return;
- }
- for (int j = 0; j < v; ++j) { //多重背包
- int k = V - j, sum = 0;
- //前n + 1个元素入队,前面的判断可以保证: V - j - n * v > 0
- for (; k >= V - j - n * v; k -= v) sum += f[k];
- for (int i = V - j; i > 0; k -= v, i -= v) {
- if (f[i]) --sum; //出队: sum -= f[i]
- else if (sum != 0) f[i] = true, ++total;
- //int tt = f[i]; f[i] = (bool)sum; sum -= tt;
- if (k >= 0) sum += f[k];
- }
- }
- }
- struct Node {
- int n, v, V;
- bool operator<(const Node& other) const { return V < other.V;}
- };
- int main()
- {
- #if AB == 1
- freopen("src.txt","r",stdin);
- freopen("z-b.txt","w",stdout);
- #endif
- Node node[MAX_N];
- int V, N;
- bool f[MAX_V];
- while (scanf("%d %d",&N,&V) != EOF) {
- if (N + V == 0) break;
- Node *np = node + N;
- for (Node *p = node; p < np; ++p) scanf("%d", &p->v);
- for (Node *p = node; p < np; ++p) {
- scanf("%d", &p->n);
- p->V = std::min(p->n * p->v, V);
- }
- std::sort(node, np);
- int total = 0;
- f[0] = true;
- for (int i = 1; i <= V; ++i) f[i] = false;
- int mv = 0;
- for (Node *p = node; p < np && total < V; ++p) {
- mv = std::min(mv + p->V, V);
- pack(f,mv,p->v,p->n, total);
- }
- printf("%d/n",total);
- }
- }
用自己随机生成的数据测试了下,上面提到的几种方法,所用时间都是7秒多点,有排序的比没排序的稍微快点。但在POJ上提交的结果,不同代码的耗时相差挺大,快的在1秒左右,慢的接近1.5秒。
还有一种特例:
给定面值为1、2、5的纸币若干个,问其所不能支付的最低价格(假设为自然数)。
这可以用多重背包(或母函数)来解决,但实际上是有O(1)解法的。
单调队列多重背包时间复杂度O(vn)相关推荐
- 多重背包-O(VN)详解
多重背包问题: 有N种物品和容量为V的背包,若第i种物品,容量为v[i],价值为w[i],共有n[i]件.怎样装才能使背包内的物品总价值最大? 网上关于"多重背包"的资料倒是不少, ...
- 【学习笔记】多重背包相关优化——二进制优化/单调队列优化
多重背包--二进制优化/单调队列优化 二进制优化 单调队列优化 代码都是 POJ1742 的,注意,那道题二进制优化会超时. 普通的多重背包式子,物品个数限制:c[i]c[i]c[i],单个物品价值 ...
- 单调队列,单调栈总结
最近几天接触了单调队列,还接触了单调栈,就总结一下. 其实单调队列,和单调栈都是差不多的数据类型,顾名思义就是在栈和队列上加上单调,单调递增或者单调递减.当要入栈或者入队的时候,要和栈头或者队尾进行比 ...
- bzoj1233 单调队列优化dp
https://www.lydsy.com/JudgeOnline/problem.php?id=1233 数据结构优化dp的代码总是那么抽象 题意:奶牛们讨厌黑暗. 为了调整牛棚顶的电灯的亮度,Be ...
- 单调队列练习之广告印刷
单调队列之广告印刷 [问题描述] 最近,afy决定给TOJ印刷广告,广告牌是刷在城市的建筑物上的,城市里有紧靠着的N个建筑. afy决定在上面找一块尽可能大的矩形放置广告牌.我们假设每个建筑物都有一个 ...
- 【单调队列优化DP】烽火传递 LibreOJ - 10180
题目来源 点我进入提交题目 反思 因为目前在学习单调队列优化DP,所以会往单调队列上面想.然后犯了一个错误就是,认为这个题目只要用单调队列就可以完成,单调队列只是用来减少时间复杂度的,遇到了求最优解的 ...
- 单调队列——广告印刷
[问题描述] 最近,afy决定给TOJ印刷广告,广告牌是刷在城市的建筑物上的,城市里有紧靠着的N个建筑. afy决定在上面找一块尽可能大的矩形放置广告牌.我们假设每个建筑物都有一个高度, 从左到右给出 ...
- 多重背包O(VN)算法——单调队列优化
多重背包问题: 有N种物品和容量为V的背包,若第i种物品容量为v[i],价值为w[i],总共有n[i]件,怎样装才能使背包内的物品总价值最大? 设dp[i][j]表示对容量为j的背包,处理完前i种物品 ...
- 多重背包单调队列优化思路_多重背包问题
题目描述: 无优化版本: int main(){int m, n;cin >> n >> m;for(int i = 1; i <= n; ++i){int v , w, ...
最新文章
- linux版_巧用linux版powershell,管理linux下的docker
- 3-V2-类和对象 -- const内联 静态成员 友元
- jsp内置对象--application
- mysql与文件_MySQL——文件
- pycharm镜像源_pycharm安装第三方库
- 使用Scrapy框架编写爬虫
- Jfinal中Cron4jPlugin使用
- linux基本命令之stat
- 【财务预警】基于matlab BP神经网络财务预警【含Matlab源码 494期】
- ArrayList源码简单剖析 及与linkedlist vector 区别
- 代写python代码一般多少钱_代写代码一般多少钱(专业解读)
- ogg与wav格式转换
- matlab生成word文档
- 华为p4不是鸿蒙吗怎么又改为安卓_鸿蒙系统是不是就是改版的安卓系统?
- 中国移动通信互联网短信网关接口协议及相关下载
- SAP 荣获「中国好公司」头衔
- 计算机和机械类哪个工资高,机械类专业就业方向 哪个方向工资高
- socket文件传输
- html页面怎么判断未登录,未登录用户.html
- Windows10 UEFI+GPT模式(解决更新显示UEFI布局问题)