多重背包-单调队列优化

多重背包经典例题：6. 多重背包问题 III - AcWing题库

 题目：

有 N 种物品和一个容量是 V 的背包。
 
第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
 
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
 
输入格式
第一行两个整数，N，V (01000, 020000)，用空格隔开，分别表示物品种数和背包容积。
 
接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。
 
输出格式
输出一个整数，表示最大价值。
 
数据范围
01000
020000
020000
提示
本题考查多重背包的单调队列优化方法。
 
输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10

多重背包解法里最常见的是转化为0-1背包。

• 1.将si个物品，每一个都当成一种物品，每种物品的体积为vi，每种物品的价值为wi，那么就变成最简单的0-1背包问题。
• 2.枚举第i种物品取的个数，比如第i中物品有s个，那我们可以取（1， 2， 3，....，s）个，这是同一组数据，最终形成的背包里，至多只在这组数据里取1个。这种方法的时间复杂读为O(NVs），在本题中复杂度过高。 后续会有代码，因为单调队列优化，优化的就是这种方法。这种
• 3.二进制优化，第i种物品有s个，我们可以取（1， 2， 3，....，s）个，可以将s拆分成几个数字，该数字可以组成（1， 2， 3，....，s）中任意一个数字。比如s=5，可以拆成5 = 1 + 2 + 3，其中1,2,3可以组成1-5中的任何数字。再比如s=7，可以拆成7=1+2+4，其中1,2,4可以组成1-7中的任何数组。那么根据什么来拆分这个s呢，可以根据二进制来拆分。具体看代码

方法一：二进制优化的代码：

对于  6. 多重背包问题 III - AcWing题库 ，该方法理论上超时，时间复杂度为O（NVlog(s)），但在把vetor改成固定数组后，也能ac。 

#include
#include
#include 
 
using namespace std;
int g1[200001], g2[200001];   //pair<体积，价值>
 
int main(){
    int N, V;   //N个物品，背包容量为V
    //scanf("%d%d", &N, &V);
    cin>>N>>V;
    int n = 0;
    for(int i = 0; i < N; ++i){
        int v = 0, w = 0, s = 0;
        cin>>v>>w>>s;
        //scanf("%d%d%d", &v,&w,&s);
        for(int j = 1; j <= s; j *= 2){    //二进制优化
            g1[n] = j*v;
            g2[n++] = j*w;
            s -= j;
        }
        if(s > 0) g1[n] = s*v, g2[n++]=s*w;     //注意将剩余的s也当成一种物品
    }
    //0-1背包
    //vector dp(V + 1, 0);
    int dp[20001] = {0};    
    for(int i = 0; i < n; ++i){
        int v = g1[i], w = g2[i];
        for(int j = V; j >= v; --j){
            if(dp[j] < dp[j - v] + w) dp[j] = dp[j - v] + w;
        }
    }
    cout<
    return 0;
}

方法二：枚举第i种物品取的个数

        比如第i中物品有s个，那我们可以取（1， 2， 3，....，s）个。此种方法可使用单调队列优化。首先给出简单版本：

#include 
#include 
#include 
 
using namespace std;
 
int main(){
    int N, V;
    cin>>N>>V;
    
    vector<int> dp(V + 1, 0);
    dp[0] = 0;
    for(int i = 0; i < N; ++i){
        int v,w,s;
        cin>>v>>w>>s;
        //用一维数组，需要注意j与k的for循环；
        //j要从V到0，因为对于属性为k*v，k*w的物品，只有一种
        //j的for循环要在k的for循环外层，因为对于第i种物品我们可以取1或2或，，，或s件，
        //（1,2,...,s）这组数据中只能选一个
        for(int j = V; j >= 0; j--){        
            for(int k = 1; k <= s; ++k){
                if(j >= k * v)
                    dp[j] = max(dp[j], dp[j - k * v] + k * w);
            }
        }
    }
    cout<
    return 0;
}

方法三：单调队列优化

该中方法是在观察方法二的基础上的出来的，现在给出方法二的滚动数组dp代码（更容易观察）

#include 
#include 
#include 
 
using namespace std;
 
int main(){
    int N, V;
    cin>>N>>V;
    
    vector<int> dp(V + 1, 0);
    vector<int> pre(V + 1, 0);
    dp[0] = 0;
    for(int i = 0; i < N; ++i){
        int v,w,s;
        cin>>v>>w>>s;
        pre = dp;   //保存当前值，后续dp会修改
        
        //j的for循环要在k的for循环外层，因为对于第i种物品我们可以取1或2或，，，或s件，
        //（1,2,...,s）这组数据中只能选一个
        for(int j = 0; j <= V; ++j){        //此时j可以从0到V
            for(int k = 1; k <= s; ++k){
                if(j >= k * v)
                    dp[j] = max(dp[j], pre[j - k * v] + k * w);//由上一层转化而来
            }
        }
    }
    cout<
    return 0;
}

根据状态转移方程dp[j] = max(dp[j], pre[j - k * v] + k * w);

我们可以得到dp[j] = max(pre[j], pre[j - v] + w, pre[j - 2*v] + 2*w, ..., pre[j - s*v] + s*w);

据此可知，dp[j]的状态只与上一层的状态j，j-v，j - 2*v，...，j - s*v有关，每个间隔v。

对于第i种物品（是种，不是个）体积为v，价值为w，可以将0到V分为v类（0到v-1）；

如（0，v，2v，...，sv, ....., kv）为一类，（1，1+v，1+2v，...，1+sv, ....，1+ kv）为一类，。。。。;那么可以抽象为，0<= r r + kv <= V。类与类之间互相独立，状态转移只发生在类内。

dp[r] = max(pre[r]);

dp[r + v] = max(pre[r] + w, pre[r + v]);

dp[r + 2v] = max(pre[r] + 2w, pre[r + v] + w, pre[r + 2v]);

dp[r + 3v] = max(pre[r] + 3w, pre[r + v] + 2w, pre[r + 2v] + w, pre[r + 3v]);

............

dp[r + sv] = max(pre[r] + sw, pre[r + v] + (s - 1)w, pre[r + 2v] + (s - 2)w，....，pre[r + sv]);

dp[r + (s+1)v] = max(pre[r + v] + sw, pre[r + 2v] + (s-1)w，.....，pre[r + (s + 1)v]);

............

dp[r + kv] = max(pre[r + (k - s)v] + sw, pre(r + (k - s + 1)v] + (s - 1)w)，......，pre[r+kv])

其中r + kv <=V。那么就可转化为滑动窗口求区间最值（窗口大小为s + 1），用单调队列做。每一类维护一个单调队列。

dp[r + v] 在dp[r]的基础上都加了一个w，后续也是如此。需要转化一下：

dp[r] = max(pre[r]);

dp[r + v] = max(pre[r] , pre[r + v] - w) + w ;

dp[r + 2v] = max(pre[r] , pre[r + v] - w, pre[r + 2v] - 2w) + 2w;

dp[r + 3v] = max(pre[r], pre[r + v] - w, pre[r + 2v] - 2w, pre[r + 3v] - 3w) + 3w;

............

dp[r + sv] = max(pre[r] , pre[r + v] - w, pre[r + 2v] - 2w，....，pre[r + sv] - sw) + sw;

dp[r + (s+1)v] = max(pre[r + v] - w, pre[r + 2v] - 2w，.....，pre[r + (s + 1)v] - (s + 1)w) + (s+1)w;

............

dp[r + kv] = max(pre[r + (k - s)v] - (k - s)w, pre(r + (k - s + 1)v] - (k - s + 1)w)，......，pre[r+kv] - kw) + kw;

 所以每次入队为pre[r + kv] - kw。

#include 
#include 
#include 
#include 
 
using namespace std;
  
int q[20011];   //队列，开在最外面，记录下标
 
int main(){
    int N,V;
    cin>>N>>V;
    vector<int> dp(V + 1, 0);
    for(int i = 0; i < N; ++i){
        int v,w,s;
        cin>>v>>w>>s;
        vector<int> pre = dp;
        //memcpy(pre, dp, sizeof(dp));
        for(int j = 0; j < v; ++j){ //第j类，共v类
            //vector<int> q(V + 1); //会超时
            int head = 0, tail = 0;
            for(int k = j; k <= V; k += v){ //下标k = j + x * v;
                while(head < tail && pre[q[tail - 1]] - (q[tail - 1] - j)/v * w <= pre[k] - (k - j)/v * w)
                    tail--;
                
                q[tail++] = k;
                while(head < tail && q[head] < k - s*v) head++;
                dp[k] = pre[q[head]] - (q[head] - j)/v * w + (k - j) / v * w; //根据公式
            }
        }
    }
    cout<
    return 0;
}