c++多重背包优化讲解

先看题，
可以看出这是一道基础的多重背包，但是多重背包优化和不优化的难度差距很大，所以我们现在再看范围

看样子数据不大我们直接贴最朴素的多重背包。

#include<bits/stdc++.h>
using namespace std;
const int N=501,V=1001;
int dp[N][V];
int main()
{
    int n,v;
    cin>>n>>v;
    for(int i=1;i<=n;i++)
    {
        int w,val,c;
        cin>>w>>val>>c;
        for(int j=0;j<=v;j++)
        {
            dp[i][j]=dp[i-1][j];
            for(int k=1;k<=c;k++)
            {
                if(k*w>j) break;
                dp[i][j]=max(dp[i][j],dp[i-1][j-k*w]+k*val);
            }
        }
    }
    cout<<dp[n][v];
    return 0;
}

很明显这段代码能过这道题，但如果数字再大一点就不好说了。我们这里先考虑一下空间复杂度，多重背包的空间复杂度 $NV$ 不难看出数值大的情况下极易MLE。

经观察我们可以发现这段代码运行过程中只用到了第 $i$ 行和第 $i-1$ 减一行,也就是说我们实际上只需要用两行就能完成这段代码,这种优化方式叫双滚动数组优化 。现在贴代码

#include<bits/stdc++.h>
using namespace std;
const int V=1001;
int dp[2][V];
int main()
{
    int n,v;
    cin>>n>>v;
    int now=1,last=0;
    for(int i=1;i<=n;i++)
    {
        int w,val,c;
        cin>>w>>val>>c;
        memcpy(dp[now],dp[last],sizeof(dp[now]));
        for(int j=0;j<=v;j++)
        {
            for(int k=1;k<=c;k++)
            {
                if(k*w>j) break;
                dp[now][j]=max(dp[now][j],dp[last][j-k*w]+k*val);
            }
        }
        swap(now,last);
    }
    cout<<dp[last][v];
    return 0;
}

一看这DP数组
{width=60%}
这空间复杂度明显降低了呀，现在变成了 $2V$，但有些题目他就是不肯让你过，结果你这么一顿优化下来还是MLE。

这时你就需要用到一维滚动数组优化，经观察我们可以发现虽然说它理论上来说用到的是两行 ，但如果只用一个数组 $dp[j]$ ，我们每次修改这个数组都是修改 $dp[1,2,\dots ,n]$ 然而当你需要第 $i-1$ 减一行的第 $j$ 个元素的时候，其实就等同于用到我们现在这个数组的第 $j$ 个元素。
然而在这个场景下如果我们正序遍历 $j$ 会破坏我们想要的 $i-1$（遍历到 $j$ 时 $j-1$ 一定已被遍历过）。因此我们需要逆序遍历 $j$。废话不多说，贴代码

#include<bits/stdc++.h>
using namespace std;
const int V=1001;
int dp[V];
int main()
{
    int n,v;
    cin>>n>>v;
    for(int i=1;i<=n;i++)
    {
        int w,val,c;
        cin>>w>>val>>c;
        for(int j=v;j>=w;j--)
        {
            for(int k=1;k<=c;k++)
            {
                if(k*w>j) break;
                dp[j]=max(dp[j],dp[j-k*w]+k*val);
            }
        }
    }
    cout<<dp[v];
    return 0;
}

这不仅空间复杂度变少了，时间复杂度也有一点优化，整个代码看起来也短了很多 。这代码总该过了吧，这道题肯定是能过的，但有些题呢你空间优化的不能再优了他就说你时间超时。
来看一下现在的时间复杂度O(n⋅V⋅max⁡{ci})O\big(n \cdot V \cdot \max\{c_i\}\big)O(n⋅V⋅max{ci​})
~~看来这种题还挺多的。~~这时我们就可以突发奇想，诶，我遍历一个商品的数量，每一次都把这个商品输入到数组里，这样不就可以视为对多个商品做01背包了吗？
哦这思路好啊，先贴代码

#include<bits/stdc++.h>
using namespace std;
const int V=1001;
int dp[V];
vector<pair<int,int>> goods;
int main()
{
    int n,v;
    cin>>n>>v;
    for(int i=1;i<=n;i++)
    {
        int w,val,c;
        cin>>w>>val>>c;
        for(int k=1;k<=c;k++)
        {
            goods.push_back(make_pair(w,val));
        }
    }
    for(int i=0;i<goods.size();i++)
    {
        int w=goods[i].first;
        int val=goods[i].second;
        for(int j=v;j>=w;j--)
        {
            dp[j]=max(dp[j],dp[j-w]+val);
        }
    }
    cout<<dp[v];
    return 0;
}

这段代码的方向对了，但怎么说呢虽然从三重循环变成了二重循环 ，但实际上他的时间复杂度是没有变化的，而且这下空间复杂度又不行了。那对这段代码进行优化我们的思路就很直观了，我们现在是把哪个商品按商品数量全都放进商品列表里进行01背包。所以我们要做的事情很简单，减少商品数量 。
我们的目的是为了让他遍历到所有有可能的商品的数量，所以这里就可以采用一点2进制了。我们不管这个商品是什么货有多少个，我们直接把这个商品的数量转成二进制 。转成二进制之后这串数就只能由零和一构成，那么比如说它的商品数量转成了一个四位二进制数。那么他肯定能变成这个形式

对正整数 $c$，构造序列
$$2^0,2^1,2^2,\dots ,2^t,r$$
满足
$$\sum _{i=0}^t{2}^i+r=c,0<r\le 2^{t+1}$$
那么我们就可以按这个方法去优化代码,这种方式叫做二进制拆分,贴代码

#include<bits/stdc++.h>
using namespace std;
const int V=1001;
int dp[V];
vector<pair<int,int>> goods;
int main()
{
    int n,v;
    cin>>n>>v;
    for(int i=1;i<=n;i++)
    {
        int w,val,c;
        cin>>w>>val>>c;
        int k=1;
        while(c>0)
        {
            int take=min(k,c);
            goods.push_back(make_pair(take*w,take*val));
            c -= take;
            k *= 2;
        }
    }
    for(int i=0;i<goods.size();i++)
    {
        int w=goods[i].first;
        int val=goods[i].second;
        for(int j=v;j>=w;j--)
        {
            dp[j]=max(dp[j],dp[j-w]+val);
        }
    }
    cout<<dp[v];
    return 0;
}

相信这段代码能通过绝大多数的题，感谢浏览本文，请点个赞和收藏以示支持。