背包九讲(多重背包问题)

多重背包我们其实可以看成为01背包和完全背包的组合。也可以把多重背包问题只转换成01背包问题，我们一起来看看解题思路。

朴素算法

基本思想

比如第i件物品有s个,我可以把相同种类的物品的进行合并,比如我拿出两件合并出一个新的物品,我拿出三件合并出一个新的物品,以此类推,我拿出s个合并出一个新的物品。基于这种思想,我们把第i件的s个物品转换为s种体积各不相同的物品,然后在用01背包的思想,求出最优解!

代码

#include<bits/stdc++.h>
using namespace std;
int v[110],w[110],s[110],m,n,f[110];
int main()
{
    cin>>m>>n;
    for(int i=1;i<=m;i++)
        cin>>v[i]>>w[i]>>s[i];
    for(int i=1;i<=m;i++)
    {
        for(int j=n;j>=1;j--)
        {
            for(int k=0;k<=s[i]&&k*v[i]<=j;k++)
            {
                f[j]=max(f[j],f[j-k*v[i]]+k*w[i]);
            }
        }
    }
    cout<<f[n]<<endl;
    return 0;
}

二进制优化算法

基本思想

大家看到名字可能心声疑惑,二进制怎么优化呢?,其实只是借助二进制思想优化朴素解法,在朴素解法中我们需要把,每一种背包i,按个数1~s,分为不同类,形成新体积的种类,这种做法虽然剪枝优化过(k*v<=j)复杂度仍然很高,问题的关键在于怎么分,我们可不可以,在分的时候换一种算法,不再是从1分到s,并且也可以表示出,1到s,产生同样的效果!答案肯定是有的,就是用二进制思想优化,我们下面讲解这种思想。

举例,有1000个苹果,11个箱子,将1000个苹果放入11个箱子中。我想拿走n个苹果!

请问,如何放,才能保证我只拿走m个箱子,就可以带走这n个苹果呢?

解:第一个箱子放2^0,个,第二个放2的1次幂个,第三个放2的2次幂个,以此类推第11个箱子,最多能放2的10次幂,即1024个,但肯定没有那么多,所以我将剩下的苹果放在第10个箱子中。
比如我要拿出 5个苹果,我只需要拿走第1个和第3个箱子,
再比如,我要拿走10个苹果,我只需要拿走,第4个和第2个即可!

通过这种思想我们可以知道,任意的1~n的整数,我都可以通过二进制的思想,表示出来。

原理:
一个数字，我们可以按照二进制来分解为1 + 2 + 4 + 8 …… +2^n + 余数

十进制数字7,可以从二进制100,010,001做加和得到即111,001为1,010为2,100为4,也就是1、2、4,用1、2、4可以表示1~7中任意一个数。
再比如,10,可以分为1,2,4,3这个三是怎么来的呢? 3就是余数!

通过上述原理,我们可以把第i件物品的s件,按二进制思想分为1,2,4…到剩余。这样从复杂度为s,降到了(log2S)。最后的复杂度为O(V*Σlog n[i]),这样就快了许多!

代码

#include<bits/stdc++.h>
using namespace std;
int vv[12100],ww[12100],m,n,v,w,s,cnt=0,f[12100];
int main()
{
    cin>>m>>n;
    for(int i=1;i<=m;i++)
    {
        cin>>v>>w>>s;
        for(int j=1;j<=s;j*=2)
        {
            vv[++cnt]=v*j;
            ww[cnt]=w*j;
            s-=j;
        }
        if(s>0)
        {
            vv[++cnt]=v*s;
            ww[cnt]=w*s;
        }
    }
    for(int i=1;i<=cnt;i++)
    {
        for(int j=n;j>=vv[i];j--)
        {
            f[j]=max(f[j],f[j-vv[i]]+ww[i]);
        }
    }
    cout<<f[n]<<endl;
    return 0;
}

单调队列优化多重背包

基本思想

首先要学习这个方法,大家一定需要学会单调队列,以及单调队列滑动窗口问题,这里我把我写的单调队列滑动窗口问题链接黏贴给大家,大家一定一定一定要先理解单调队列滑动窗口,不然后面很难跟上!

我通过朴素解法,添加了打印语句,将每一次的f数组的更新过程记录下来!

 f[j]=max(f[j],f[j-k*v]+k*w);
 //打印语句
printf("f[%d]=%2d f[%d]+%d=%d\n",j,f[j],j-k*v,k*w,f[j-k*v]+k*w);

控制台第一行,代表2组数据,背包总体积为9
第二行是,第一种物品,体积为2,价值为4,件数为3!
接下来就是f数组更新过程,可以看到左边那列为f[j],右边那列为f[j-kv]+kw,整条f的信息也就是动态转移方程。

重点来了,通过上述规律,我可以将f[9],f[7],f[5],f[3],f[1]归于一类
同理,我将f[8],f[6],f[4],f[2],f[0]归于一类!

那么为什么会得到这样的规律呢? (分析一波,走你~~~~)
首先背包总体积为9,第一件物品体积为2,那么我最多放4件,但是只有三件,所以红框的高度最多为3。

那么为什么分两类呢? 这与物品体积有关! 9,7,5,3,1对体积2取余数,结果都为1,
0,2,4,6,8对体积取余为0!
那么可以得到一般性规律我们可以分出以0~(v-1)开头的k个类
这组数据,就是以0、1开头,1就是v-1即2-1。

下面就要用到单调队列滑动区间的知识,如果对单调队列滑动区间不熟悉,那么很难理解,所以大家不要好高骛远,先把上面的链接看了!如果懂得单调队列滑动区间知识的我们往下看!

我们再来看这张图,上边说过类的概念,在同一类中,红框依次向下更新,像不像一个滑动区间,我需要找出,窗口内右边那列的的最大值然后赋值给f[j]。

那么如何找出窗口内的最大值呢,或者说如何维护窗口内的最大值呢?

答案就是用单调队列
这道题我们的单调队列一定是从小到大(f[1]~f[9]这个顺序更新)来维护,每次放入队列中较大元素的下标,队首永远是窗口内的最大值。如果从上一个窗格滑动到下一个窗格如果此时队首下标不在这个窗格中,我们就不能用这个队首来更新最大值,需要把队首踢出去也就是head++操作,用新的head来更新,当前窗口最大值。
有了单调队列维护,每次更新f[j]只需要一次操作!而不是三次操作!

(注意:这个较大元素是包括了f[j-kv]+kw是他们一起,而不是单个的f[j-k*v])

举例: f[0] 、f[2]、f[4]、f[6]、f[8]
此时需要更新f[8],但是f[8]是能装下3件的,所以窗口大小为3,但此时单调队列队首停在f[0],那么我就需要将f[0]出队,然后从f[2],f[4],f[6]中选出最大的作为队首,来更新!(我只是举例,实际选最大还要加上k*w)

针对单调队列,不知道大家有没有几个问题?
一、这道题用的单调队列从小到大更新,会产生什么后果呢?如何解决呢?

举例,比如我刚刚更新的f[7],然后我去更新f[9],通过上面的例子可以知道,要想更新f[9],就需要f[7],f[5],f[3],但是f[7],f[5],f[3]都已经更新过了,我们就不能在用了!(因为我是从f[1]~f[9]这么更新过来的)
(如果这个不明白,那么证明01背包问题理解不透彻,不如再看看01背包再过来!)

解决措施:我新添加一个数组g存放f数组的初始值,也就是还没有更新的f数组的值,然后将g数组用单调队列维护,每次更新f中的值我只需要从g中所对应的窗口选出最大的即可!
举例,我想更新f[8],我就从g[6],g[4],g[2]中选出最大的给f[8],就可以了!

这是顺序更新,从f[0]~f[8],红框代表单调队列维护过程,并且用了g数组!

说了这么多那么单调队列里到底存个啥呢?存窗口中最大的值,还是下标呢?

答案是下标,下标方便我们判断队首是否在滑动窗口中,并且下标好维护!

代码

#include <iostream>

using namespace std;

const int N = 1010, M = 20010;

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

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)
    {
        for (int r = 0; r < v[i]; ++ r)
        {
            int hh = 0, tt = -1;
            for (int j = r; j <= m; j += v[i])
            {
                while (hh <= tt && j - q[hh] > s[i] * v[i]) hh ++ ;
                while (hh <= tt && f[i - 1][q[tt]] + (j - q[tt]) / v[i] * w[i] <= f[i - 1][j]) -- tt;
                q[ ++ tt] = j;
                f[i][j] = f[i - 1][q[hh]] + (j - q[hh]) / v[i] * w[i];
            }
        }
    }
    cout << f[n][m] << endl;
    return 0;
}