多重背包及其优化

有 $N$ 份物品和一个容量是 $M$ 的背包。

第 $i$ 份物品有 $s_i$ 件，每件体积是 $v_i$，价值是 $w_i$。

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

I. 朴素解

直接拆成 ${\sum }_{i=1}^n{s}_i$ 个01背包求解。时间复杂度 $O(n\ast s\ast V)$，同数量级下复杂度为 $O(n^3)$。

#include<bits/stdc++.h>
using namespace std;
const int M = 105;

int dp[M];

int main(){
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int n,m;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++) // 对每组做s次01背包
        for(int j=m;j-v>=0;j--){
            dp[j]=max(dp[j], dp[j-v]+w);
        }
    }
    cout<<dp[m]<<endl;
    return 0;
}

II. 二进制优化

把每一份物品二进制拆分（注意要从小到大拆分才能完全表示），这样就将 $s_i$ 件物品变成 $log{s}_i$ 件物品，从而时间复杂度降为 $O(n\ast logs\ast V)$。

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
const int M = 2005;

int dp[M];

int main(){
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int n,m;cin>>n>>m;
    vector<PII> vec;
    for(int i=1;i<=n;i++){
        int v,w,s;cin>>v>>w>>s;
        int k=1;
        while(k<=s){
            vec.push_back({v*k,w*k}); // 拆分成若干部分
            s-=k;
            k*=2;
        }
        if(s) vec.push_back({v*s,w*s}); // 剩余
    }
    // n*log(s) 个01背包
    for(auto& [v,w]:vec){
        for(int j=m;j-v>=0;j--){
            dp[j]=max(dp[j], dp[j-v]+w);
        }
    }
    cout<<dp[m]<<endl;
    return 0;
}

III. 单调队列优化

事实上，转移只会发生在「对当前物品体积取余相同」的状态之间。

举个栗子，假设当前我们处理到的物品体积和价值均为2，数量为3，而我们背包容量为10。

• $dp[10]$ 只能由 $dp[8]$、$dp[6]$、$dp[4]$ 转移而来

• $dp[9]$ 只能由 $dp[7]$、$dp[5]$、$dp[3]$ 转移而来

  …

• $dp[5]$ 只能由 $dp[3]$、$dp[1]$ 转移而来

• $dp[4]$ 只能由 $dp[2]$、$dp[0]$ 转移而来

• $dp[3]$ 只能由 $dp[1]$ 转移而来

• $dp[2]$ 只能由 $dp[0]$ 转移而来

• 当然还有不选的情况，直接从上一层转移过来

若当前状态为 $k$，前面可转移过来的状态 $x$ 应该满足 $\frac{k-x}{v}\le s$。

下面是维护单调队列的方程转移。

状态的更新应为 $dp[k]=d{p}^{\prime }[x]+\frac{k-x}{v}\ast w$。同时要每次取队头的价值都是最大，故维护的单调队列下降。

这样每次转移就是 $O(M)$，总时间复杂度 $O(n\ast m)$。

#include<bits/stdc++.h>
using namespace std;
const int M = 20004;

int dp[2][M];
int q[M];

int main(){
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++){
        int v,w,s;cin>>v>>w>>s;
        for(int j=0;j<=m;j++) dp[i&1][j]=0;
        for(int j=0;j<v;j++){ // 枚举能产生余数的数
            int hh=0, tt=-1;
            for(int k=j;k<=m;k+=v){
                while(hh<=tt && (k-q[hh])/v>s) hh++; // 不满足转移条件的状态出队
                // 维护单调队列下降, 注意比较的是i-1维
                while(hh<=tt && dp[i&1^1][q[tt]]+(k-q[tt])/v*w <= dp[i&1^1][k]) tt--; 
                q[++tt]=k; // 因为可以不选, 要将k状态先加入
                dp[i&1][k]=max(dp[i&1][k], dp[i&1^1][q[hh]]+(k-q[hh])/v*w); // 更新答案
            }
        }
    }
    cout<<dp[n&1][m]<<endl;
    return 0;
}