多重背包-暴力法+ 单调队列优化法

多重背包-暴力法+ 单调队列优化法

暴力法

问题:一共 n 类物品，背包的容量是 m 每类物品的体积为v, 价值为w，个数为s，求背包内价值的最大值。

数据范围：
$$\begin{gathered} 0<N\le 1000 \\ 0<V\le 20000 \\ 0<v_i,w_i,s_i\le 20000 \end{gathered}$$
思路:因为每个物品的选几个受当前背包容量的影响，如果选的话还会改变背包剩下的容量，然后进一步影响后面的物品的选择，所以将背包的体积作为状态，(这是我自己为什么选这个作为状态的原因，，，)

那么定义$dp[i][j]$为从前i个物品中，且体积不超过 j 的选法的集合。

那么先考虑第 i 个物品选多少个，那么就有下面的方程 （v为当前物品的体积，w为当前物品的价值$s_i$为最多取几个）

$dp[i][j]=max(dp[i-1][j],dp[i-1][j-v]+w,dp[i-1][j-2\ast v]+2\ast w,...,dp[i-1][j-s_i\ast v]+s_i\ast w)$

然后我们发现求$dp[i][j]$的时候涉及到的都是$i-1$中$j$前面的数据，所以如果我们倒叙遍历$j$就不需要第一维度了。

通过第一层for遍历物品，第二层for遍历体积，第三层遍历选法就可以得到结果了，但这样做的时间复杂度是时间复杂度是$O(物品数\ast 背包的体积\ast 选法)$ = $O(1000\ast 20000\ast 20000)$显然会超时，只不过这里先不管。

下面是省掉一维时候的代码：

#include <stdio.h>
#include <algorithm>
using namespace std;
const int N = 6005;
int dp[N], n, m;
int main()
{
    scanf("%d%d", &n, &m);
	//遍历物品
    while (n--)
    {
        int v, w, s;
        scanf("%d%d%d", &v, &w, &s);
        //遍历体积
        for (int i = m; i >= v; i--)
            //遍历选法
            for (int j = 0; j <= s && v * j <= i; j++)
                dp[i] = max(dp[i], dp[i - j * v] + j * w);
    }
    printf("%d", dp[m]);
    return 0;
}

对应习题:Acwing 1019庆功宴(这道题直接暴力就可以了)

单调队列优化法

因为上面暴力必然超时，所以我们这里要寻找哪里可以优化，先看下最原始的方程

$dp[i][j]=max(dp[i-1][j],dp[i-1][j-v]+w,dp[i-1][j-2\ast v]+2\ast w,...,dp[i-1][j-s_i\ast v]+s_i\ast w)$

我们可以发现该方程的第二维是$j-v,j-2\ast v,j-3\ast v,j-s_i\ast v$，因为受到完全背包的感染，所以写以下$dp[i][j-v]$的方程来对比看一下。
$$\begin{gathered} dp[i][j-v]=max(dp[i-1][j-v],dp[i-1][j-2\ast v]+w \\ ,...,dp[i-1][j-s_i\ast v]+(s_i-1)\ast w)+dp[i-1][j-(s_i+1)v+w\ast s_i] \end{gathered}$$

从图中可以看出来，一开始是匹配的，但是最后一个不匹配，也就是$ j$没有$j-1$的最后一项，所以
$$\begin{gathered} max(dp[i-1][j],dp[i-1][j-v]+w,dp[i-1][j-2\ast v]+2\ast w,...,dp[i-1][j-s_i\ast v]+s_i\ast w) \\ \ne \\ max(dp[i-1][j-v],dp[i][j-v]) \end{gathered}$$
虽然猜想不对，但是我们发现了$dp[i][j]对比dp[i][j-v]$的方程中间有一大部分是匹配的，而且是后面少一项和前面多一项的关系，想利用这一部分，就想到了一个非常匹配这个过程的方法—滑动窗格。

为了方便，我们这里使用滚动数组，将$dp[i-1][j]$的值全部存在$pre$数组里面。$pre[j]=dp[i-1][j]$

$pre[j]$的含义是从前$i-1$个物品中选，且体积不超过$j$的最大价值。

那么假设$s_i$==3，$dp[i][j]=max(pre[j],pre[j-v]+w,pre[j-2\ast v]+2\ast w,pre[j-3\ast v]+3\ast w)$

可以看出来，当前的窗格需要从前面往后推,然后边推还可以边把$dp[i][j-v],dp[i][j-?\ast v]$全给赋值了，然后可以发现以下两点

• 不能像暴力法那样，直接丢掉一维，不然你求$j-5\ast v$的时候，要用到$j-6\ast v$已经被覆盖掉了，所以用一个滚动数组pre来存储

• 因为前往后推，所以我们先要找到起点的体积比如说上图就是$j-6\ast v,假设0<j-6\ast v<v$。

起点有0 到$v-1$种可能，那么我们这里就可以换一种写法了比如说
$$\begin{gathered} 假设j-6\ast v=2,0<2<v \\ 那么j-5\ast v=2+v,j-4v=2+2\ast v...j=2+6\ast v \\ 去掉等号一边就是2,2+v,2+2\ast v,...,2+6\ast v \\ 那么max(pre[j],pre[j-v]+w,pre[j-2\ast v]+2\ast w,pre[j-3\ast v]+3\ast w) \\ 变成max(pre[2+6\ast v],pre[2+5\ast v]+w,pre[2+4\ast v]+2\ast w,pre[2+3\ast v]+3\ast w) \end{gathered}$$
上面是具体的写法，下面将其抽象化：$总体积m=k\ast v+j，0<j<v$,先不管后面加的部分
$$pre[2],pre[2+v],pre[2+2\ast v],pre[2+3\ast v],...,pre[k\ast v+2]$$
写到这里，我们发现，其实我们枚举$0<j<v$然后一直推到这个$j$对应的结尾就可以完成这个物品的更新了。这里补全一下抽象化后的整个表示
$$\begin{gathered} pre[0],pre[v],pre[2\ast v],pre[3\ast v],...,pre[k\ast v] \\ pre[1],pre[v+1],pre[2\ast v+1],pre[3\ast v+1],...,pre[k\ast v+1] \\ pre[2],pre[v+2],pre[2\ast v+2],pre[3\ast v+2],...,pre[k\ast v+2] \\ pre[3],pre[v+3],pre[2\ast v+3],pre[3\ast v+3],...,pre[k\ast v+3] \\ ... \\ pre[j],pre[v+j],pre[2\ast v+j],pre[3\ast v+j],...,pre[k\ast v+j] \\ 每一行滑动过去，比如s=3的话,一开始是j,v+j,2\ast v+j \\ 下一个就是v+j,2\ast v+j,3\ast v+j这样边滑边更新 \end{gathered}$$
然后现在知道怎么更新，还知道怎么全部都更新，剩下的就是怎么快速的找到滑动窗格的最大值，那么单调队列登场，因为直接用deque会超时，所以这里用数组模拟整个过程，有点小复杂？只不过我会尽力讲清楚的。

另起一个数组为q[N]，里面存的是背包的体积，设置队列头为head,尾巴为tail q[头, , , ,…,尾巴],保证队列里面是单调的，也就是head代表的体积的价值>tail代表的体积的价值。

现在问题来到怎么维护单调队列的单调性?

当前的背包体积k，因为要单调队列的单调性，所以要找到一个合适的位置讲当前背包放入队列中，这个合适的位置的体积的最大价值大于体积k的最大价值才行，$pre[q[tail]]$取得的就是当前尾部体积的价值相当于$dp[i-1][q[tail]]$和当前的价值$dp[i-1][k]$比较，有没有发现什么不对劲？

$pre[j]$的含义是从前$i-1$个物品中选，且体积不超过$j$的最大价值。$pre[h]=dp[i-1][h]$

$dp[i][j]=max(dp[i-1][j],dp[i-1][j-v]+w,...,dp[i-1][j-s_i\ast v]+s_i\ast w)$

看眼原始方程，回忆下变量的含义。没错漏掉了$k-q[tail]$这部分给$dp[i-1][q[tail]]$带来的价值，所以比较的时候要给加回去继续比较，那么就可以写出这部分的代码了

可以对比起来看一下
$$\begin{gathered} dp[i-1][j-?\ast v]+?\ast w \\ pre[q[tail]]+(k-q[tail])/v\ast w \end{gathered}$$

while (head <= tail && pre[q[tail]] + (k - q[tail]) / v * w <= pre[k])
             tail--;

接下来直接看完整代码就可以了：

#include <stdio.h>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 20005;
// pre存储i - 1的时候的值
// q为偏移量为?时候的单调队列
int dp[N], pre[N], q[N], n, m;
int main()
{
    //n为物品的总数，背包容量为m
    scanf("%d%d", &n, &m);
    while (n--)
    {
        int v, w, s;
        scanf("%d%d%d", &v, &w, &s);

        //赋值上一层结果
        memcpy(pre, dp, sizeof(dp));

        //枚举偏移量(起点)
        for (int i = 0; i < v; i++)
        {
            //建新的单调队列 头>>>尾巴，里面存的是体积
            int head = 0, tail = -1;

            //更新该起点代表的行,k是此时的体积
            for (int k = i; k <= m; k += v)
            {
                //判断窗格是否超过了k,头需要往后滑动
                if (head <= tail && k - q[head] > s * v)
                    head++;

                //赋值
                //pre[q[head]]+(k - q[head]) / v * w)：前i-1个中选，且体积不大于q[head]的最大价值 + 第i个物品选(k - q[head]) / v 个的价值
                if (head <= tail)
                    dp[k] = max(dp[k], pre[q[head]] + (k - q[head]) / v * w);

                //队列中加入k,并且维护队列单调性
                //pre[k]：前i-1个中选，且体积不大于q[head]的最大价值 + 第i个物品选0个
                //pre[q[tail]] + (k - q[tail]) / v * w ：前i-1个中选，且体积不大于q[tail]的最大价值 + 第i个物品选(k - q[tail]) / v个
                while (head <= tail && pre[q[tail]] + (k - q[tail]) / v * w < pre[k])
                    tail--;
                q[++tail] = k;
            }
        }
    }
    printf("%d", dp[m]);
    return 0;
}

习题：AcWing 6. 多重背包问题 III