day52：多重背包问题Ⅰand Ⅱ and Ⅲ（动态规划）

问题描述:
有 N 种物品和一个容量是 V 的背包。第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

• 输入格式
  第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。
• 输出格式：输出一个整数，表示最大价值。
  数据范围
  0<N,V≤100
  0<vi,wi,si≤100
• 输入样例
  4 5
  1 2 3
  2 4 1
  3 4 3
  4 5 2
• 输出样例：
  10

与01背包问题相比较多了一层循环用于遍历物品的个数。还有的做法是将该问题转化为单纯的01背包问题，然后求解。

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

int n,m;
int f[N];
int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        int v,w,s;
        cin>>v>>w>>s;
        for(int j=m;j>=v;j--)
        {
            for(int k=1;k<=s&&k*v<=j;k++)
            {
                f[j]=max(f[j],f[j-k*v]+k*w);
            }
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;

const int N = 110;
int f[N][N];
int main()
{
    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++)
        {
            for(int k=0;k<=s&&j>=k*v;k++)
            {
                f[i][j]=max(f[i][j],f[i-1][j-k*v]+k*w);
            }
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

数据范围
0<N≤1000
0<V≤2000
0<vi,wi,si≤2000

上一个问题是数据范围局限在100，而这个数据范围明显增大了，如果按照上边的做法会导致内存不够。所以不按照上面那个做法依次每个物品每个物品进行计算，将该物品总数进行划分，按照二进制方式划分，将这些物品重新划分为商品个数为1个，2个，4个，……的若干个”新的商品 “，之后按照上一题目中的解法进行遍历。参考链接

#include<bits/stdc++.h>
using namespace std;
const int N=2010;
int n,m;
int f[N];
struct Good
{
    int v,w;
};
int main()
{
    vector<Good> goods;
    cin>>n>>m;
    for(int i=0;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(auto good:goods)
    {
        for(int j=m;j>=good.v;j--)
        {
            f[j]=max(f[j],f[j-good.v]+good.w);
        }
    }
    cout<<f[m]<<endl;
}

再进一步数据范围更大呢？
数据范围
0<N≤1000
0<V≤20000
0<vi,wi,si≤20000

使用到了单调队列。参考链接1 参考链接2

dp[m] = max(dp[m], dp[m-v] + w, dp[m-2v] + 2w, dp[m-3v] + 3w, ……)该式子是优化过的式子，遍历顺序是从大到小遍历。
接下来，我们把 dp[0] 到 dp[m] 写成下面这种形式
dp[0], dp[v], dp[2v], dp[3v], ……, dp[t*v]

dp[1], dp[v+1], dp[2 * v+1], dp[3 * v+1], .…… , dp[t*v+1]

dp[2], dp[v+2], dp[2 * v+2], dp[3 * v+2],…… , dp[t*v+2]

dp[j], dp[v+j], dp[2v+j], dp[3v+j], …… , dp[t*v+j]
取值范围：m == t * v + j，其中 0 <= j < v, t：指的是个数范围0<= t < (m-j)/v 。可以将数m==v 和 j=0 代入式子计算，依次尝试几个数字，可以得到上面的规律。

也就是每组指的是j % v 余数相等的那组会划分为一类。进而求解的是每一组中的最大值，且每一类之间都是互斥的。
我们需要求解的是{ dp[j], dp[v+j], dp[2* v+j], dp[3* v+j], ……, dp[t*v+j]}中的最大值，j 从0开始遍历,花括号里指的是所有dp矩阵中的元素。

所以，按照动态规划方程得到：
dp[j] = dp[j]
dp[j+v] = max(dp[j] + w, dp[j+v])
dp[j+2v] = max(dp[j] + 2w, dp[j+v] + w, dp[j+2v])
dp[j+3v] = max(dp[j] + 3w, dp[j+v] + 2w, dp[j+2v] + w, dp[j+3v])
……
但是，这个队列中前面的数，每次都会增加一个 w ，所以我们需要做一些转换
dp[j] = dp[j]
dp[j+v] = max(dp[j], dp[j+v] - w) + w
dp[j+2v] = max(dp[j], dp[j+v] - w, dp[j+2v] - 2w) + 2w
dp[j+3v] = max(dp[j], dp[j+v] - w, dp[j+2v] - 2w, dp[j+3v] - 3w) + 3w
……
这样，每次入队的值是 dp[j+tv] - tw 这里的 t 指的是物品个数。代码里的k指的是体积。

滑动窗口需要维护窗口大小，在本题中窗口大小指的是可放入物品的数量，如果当前体积 k 减去队头体积q[hh] 除以 体积 v 大于了物品仅有的个数 s 也就是 (k-q[hh])/v>s 则，队头向前移动，否则需要计算当前体积k下的最大值。理解功能是含义时代码里的字母表示的含义与式子表示的含义要区分一下，不然理解跑偏了。
何时出队呢？若队尾元素小于当前元素，就要出队。最后需要给队尾赋值。 代码里的k 指的是公式中的 t +j * v ，

没有入队完整的 dp[j+t* v] - t * w 原因在于 ：

对于这么多次k循环，j 是在外层，可以看做 j 无变化，变化的是 t ,更新队尾元素的时候已经按照该条件更新了，且在计算最后结果就需要加上这部分t * w 也就是(k-q[hh])/v * w 体积。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=20010;
int f[N],q[N],g[N];

int n,m;
int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        int v,w,s;
        cin>>v>>w>>s;
        memcpy(g, f, sizeof(f));
        for(int j=0;j<v;j++)
        {
            int hh=0,tt=-1;
            for(int k=j;k<=m;k+=v)
            {
                if(hh<=tt && (k-q[hh])/v>s) hh++;
                if(hh<=tt) f[k]=max(f[k],g[q[hh]]+(k-q[hh])/v*w);
                while(hh<=tt && (g[q[tt]]-(q[tt]-j)/v*w)<=(g[k]-(k-j)/v*w) ) tt--;
                q[++tt]=k;
            }
        }
    }
    cout<<f[m]<<endl;
    return 0;
}