01背包详解，状态设计，滚动数组优化，通用问题求解

0/1背包

前言

0/1包问题，作为动态规划问题的经典问题，可以帮助捋顺思维。核心就是有一堆物品,有两个维度的限制，在保证一个维度限制的情况下，使得另一个维度最优。

一、0/1背包的状态设计

有n(n≤100)个物品和一个容量为m(m≤10000)的背包。
第i个物品的容量是c[i]，价值是w[i]。现在需要选择一些物品放入包, 总容不能超过背包容量，求能够达到的物品的最大总价值。

以上就是0/1背包问题的完整描述,之所以叫0/1背包，因为每种物品只有一个,可以选择
放入背包或者不放，而0代表不放，1 代表放。

1、状态设计

状态(i, j)表示前i个物品恰好放入容量为j的背包(0≤i<n，0≤j≤m);
令dp表[][]示状态(i, j)下该背包得到的最大价值，即前i个物品恰好放入容量为j的背包所得
到的最大总价值;

2、状态转移方程

列出状态转移方程如下:
$$dp[i][j]=max(dp[i?1][j],dp[i?1][j?c[i]]+w[i])$$
因为每个物品要么放,要么不放,所以只需要考虑第i个物品放或不放的情况:

1)不放:如果第i个物品不放入容量为j的背包",那么问题转化成求"前i-1 个物品放入容为j的背包"的问题;于不放,所以最大价值就等于"前i-1个物品放入容量为j的背包"的最大价值，即dp[i-1][j];

2)放:如果"第i个物品放入容为j的背包"，那么问题转化成求"前i-1个物品放入容量为j-c[j]的背包"的问题;那么此时最大价值就等于"前i-1个物品放入容为j-c[i] 的背包"的最大价值加上放入第i个物品的价值,即dp[i-1][j - c[i]] + w[i]
将以上两种情况取大者,就是我们所求的“前i个物品恰好放入容量为j的背包"的最大价值了。

3、初始状态

我们发现，当状态在进行转移的时候，dp(i, j)不是来自dp(i - 1 , j),就是来自dp(i - 1 , j - c[i])，所以必然有一个初始状态，而这个初始状态就是(0, i)，含义是"前i个物品放入一个容量为0的背包"，这个状态下的最大价值为0,即dp[0][i] = 0;

4、代码实现

铺垫了那么多，我们来实现一下0/1背包的板子。

//#define N 110
//#define M 1010
//int dp[N][M]{0}, c[N]{0}, w[N]{0}, n, m;
//c[i]为第i个物品的重量，w[i]为第i个物品的价值。n、m分别为物品数和背包容量
for (int i = 1; i <= n; i++)
    for (int j = 0; j <= m; j++)
        if (j < c[i])
            dp[i][j] = dp[i - 1][j];
        else
            dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - c[i]] + w[i]);

5、滚动数组优化

滚动数组优化为递推问题中的常用空间优化手段，如果每次递推都由上一次状态转移那么我们可以将空间降低一个维度。

我们再看状态转移图

发现每个状态都只跟上一行同一列和上一行左边的状态有关，我们可以开两个一维数组，分别保存上一行和当前行的状态，当然也可以只用一个一维数组然后倒序递推来实现。

二维优化为两个一维

两个一维数组一个保存上一行的状态一个保存当前行状态即可。

#define N 110
#define M 1010
int dp1[M]{0}, dp2[M]{0}, c[N]{0}, w[N]{0}, n, m;
for (int i = 1; i <= n; i++)
    cin >> c[i] >> w[i];
for (int i = 1; i <= n; i++)
{
    for (int j = 0; j <= m; j++)
        if (j < c[i])
            dp2[j] = dp1[j];
        else
            dp2[j] = max(dp1[j], dp1[j - c[i]] + w[i]);
    memcpy(dp1, dp2, sizeof(dp1));
}
cout << dp2[m];

二维优化为一个一维，倒序递推

即然每次状态都只由上一行当前列和当前行左侧列转移，我们发现两个一维优化方案中，dp1其实是也可以优化掉的，假如只剩下一个一维数组dp，如果我们正序递推会怎样？

初始时dp中存储上一次状态转移的数据，如果正序递推则导致我们状态转移需要上一次状态但是由于正序递推覆盖了左侧内容，就无法获取上一次状态了，所以我们选择逆序递推：

#define N 110
#define M 1010
int dp[M]{0}, dp2[M]{0}, c[N]{0}, w[N]{0}, n, m;
for (int i = 1; i <= n; i++)
    cin >> c[i] >> w[i];
for (int i = 1; i <= n; i++)
{
    for (int j = m; j >= c[i]; j--)
            dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
}
cout << dp[m];

---

二、0/1背包的通用问题

求最大值

原题链接

[P1048 NOIP2005 普及组] 采药 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

01背包板子题，读完数据跑一遍板子，输出数据即可。

#include <iostream>
#include <cstring>
#include <vector>
#include <functional>
#include <algorithm>
#include <cmath>
#include <functional>
#include <climits>
#include <bitset>
#include <stack>
#include <cstring>
using namespace std;
#define N 110
#define M 1010
int dp[M]{0}, c[N]{0}, w[N]{0}, n, m;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    cin >> m >> n;
    for (int i = 1; i <= n; i++)
        cin >> c[i] >> w[i];
    for (int i = 1; i <= n; i++)
    {
        for (int j = m; j >= c[i]; j--)
            dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
    }
    cout << dp[m];
    return 0;
}

---

[P1060 NOIP2006 普及组] 开心的金明 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

同样是01板子题，只不过物品价值变成了重量乘价值

#include <iostream>
#include <cstring>
#include <vector>
#include <functional>
#include <algorithm>
#include <cmath>
#include <functional>
#include <climits>
#include <bitset>
#include <stack>
#include <cstring>
using namespace std;
#define N 30010
#define M 100000000
int dp[M]{0}, c[N]{0}, w[N]{0}, n, m;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    cin >> m >> n;
    for (int i = 1; i <= n; i++)
        cin >> c[i] >> w[i], w[i] *= c[i];

    for (int i = 1; i <= n; i++)
    {
        for (int j = m; j >= c[i]; j--)
            dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
    }
    cout << dp[m];
    return 0;
}

---

P3985 不开心的金明 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

在不考虑内存的情况下显然是一道01背包板子题，但是你这个1e9的背包内存肯定会爆，内存不爆你时间复杂度也会爆，但是金明妈妈限制了物品重量极差不超过3（感谢金明妈妈！！！！），我们就可以将物品重量离散化到1，2，3，4上，即我们记录最小重量mi，再令每个重量减去(mi - 1)，这样物品重量就变为了1，2，3，4

由于物品数目最多100，所以物品总重量最大也就400，我们离散化后再去跑01背包的板子即可

但是！！！

有一个问题，你怎么根据离散化后的重量计算离散化前的重量呢？看我们的板子

for (int i = 1; i <= n; i++)
{
    for (int j = sum; j >= c[i]; j--)
        dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
}

此时j为离散化后的重量了，你怎么确定你上面的状态方程就合法呢？如果一共给了m的空间，你此时的j对应实际重量为j + cnt * mi，cnt为装的物品数目，故而我们需要给dp增加一个维度来记录装入的物品数目

dp[i][j]就代表容量i装入了j个物品的最大价值，此时装入总重量不超过i + j * mi，（不超过是因为i可能大于j个物品的离散重量）

这样一来我们的空间复杂度只有1e2量级，时间复杂度只有1e6量级

代码如下：

#include <iostream>
#include <cstring>
#include <vector>
#include <functional>
#include <algorithm>
#include <cmath>
#include <functional>
#include <climits>
#include <bitset>
#include <stack>
#include <cstring>
using namespace std;
#define N 110
#define M 550
int dp[M][N]{0}, c[N]{0}, w[N]{0}, n, m, mi = INT_MAX, sum = 0, ans = 0;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> c[i] >> w[i], mi = min(mi, c[i]);
    mi--;
    for (int i = 1; i <= n; i++)
        c[i] -= mi, sum += c[i];

    for (int i = 1; i <= n; i++)
    {
        for (int j = sum; j >= c[i]; j--)
            for (int k = (m - j) / mi ; k >= 1; k--)
                ans = max(ans, dp[j][k] = max(dp[j][k], dp[j - c[i]][k - 1] + w[i]));
    }
    cout << ans;
    return 0;
}

---

求最小值

原题链接

[P1049 NOIP2001 普及组] 装箱问题 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

本质还是求最大值。

在本题内，重量就是体积，价值也是体积，我们求出能装的最大体积，容量减去最大体积就是答案。

#include <iostream>
#include <cstring>
#include <vector>
#include <functional>
#include <algorithm>
#include <cmath>
#include <functional>
#include <climits>
#include <bitset>
#include <stack>
#include <cstring>
using namespace std;
#define N 50
#define M 20010
int dp[M]{0}, c[N]{0}, w[N]{0}, n, m;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    cin >> m >> n;
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    for (int i = 1; i <= n; i++)
    {
        for (int j = m; j >= c[i]; j--)
            dp[j] = max(dp[j], dp[j - c[i]] + c[i]);
    }
    cout << m - dp[m];
    return 0;
}

---

求方案数

原题链接

P1164 小A点菜 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

对于本道题我们的dp[i][j]就变成了j元恰好买i道菜的方案数

对于初始状态即0元购0菜方案为1，其他0元购都是0

那么我们同样对于每道菜可以选择买或不买，可以选择用j元恰好买i - 1道菜也可以选择用j元恰好买i道菜，那么转移方程就变成了

dp[i][j] = dp[i - 1][j] + dp[i - 1][j - c[i]]

#include <iostream>
#include <cstring>
#include <vector>
#include <functional>
#include <algorithm>
#include <cmath>
#include <functional>
#include <climits>
#include <bitset>
#include <stack>
#include <cstring>
using namespace std;
#define N 110
#define M 10010
int dp[M]{0}, c[N]{0}, w[N]{0}, n, m;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    dp[0] = 1;
    for (int i = 1; i <= n; i++)
    {
        for (int j = m; j >= c[i]; j--)
            dp[j] += dp[j - c[i]];
    }
    cout << dp[m];
    return 0;
}

https://www.luogu.com.cn/problem/P3985)

416. 分割等和子集

剑指 Offer II 101. 分割等和子集

1262. 可被三整除的最大和

这道题目如何转化为0/1背包问题呢，我们这里的背包容量是3，因为我们对3取余只有0，1，2三种情况，

那么我们的每个数字对于3取余的结果就是它的重量，其值就是价值

只不过我们以往放入背包里面还要考虑背包已满的情况，在这里便不用了，因为我们放入一个数字后，和对3取余结果仍在3以内，只不过我们最后要的是对三取余为0的最大和罢了

dp[ i ] [ j ]代表前i个数字放入对取余为j的背包里面的最大和，dp[ i ] [ i ] = max(dp[ i - 1] [ (j - nums[i] % 3) % 3 ] + nums[ i ] , dp[i - 1] [ j ])

但对于j - nums[i] % 3) % 3会有负值，我们可以改为

dp[ i ] [(nums[i] % 3 + j) % 3] = max(dp[i - 1] [ j ] + nums[ i ] , dp[ i - 1 ] [(nums[i] % 3 + j) % 3] );

显然我们可以用滚动数组优化为一维空间，但是我们本题dp虽然从i - 1转移，但转移的容量未必比新容量小，所以每次要提前用一个prev数组来保存dp数组的旧值，一共需要三个元素的空间

如此一来，有递推

dp[(nums[j] % 3 + i) % 3] = max(prev[i] + nums[j] , dp[(nums[j] % 3 + i) % 3]);

代码如下：

class Solution {
public:
    int maxSumDivThree(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp{0 , INT_MIN , INT_MIN};
        
        for(int j = 0 ; j < n ; j++)
        {
            vector<int>prev(dp);
            for(int i = 0 ; i < 3 ; i++)
            dp[(nums[j] % 3 + i) % 3] = max(prev[i] + nums[j] , dp[(nums[j] % 3 + i) % 3]);
         
        }
        return dp[0];
    }
};

1774. 最接近目标价格的甜点成本

这个0/1背包问题呢，没有定死背包的容量，而是给我们物品，不限制容量，让你找一个方案使得装的物品的总重量最接近给定的target

那么我们的关注点在于对于一个容量我们能不能装

所以我们只要找到方案价格上限作为我们的背包容量，然后套用模板枚举即可

方案上限对应target取上限10000

对于方案我们无非有三种情况

只选基料

上限为10000

基料加一个辅料

base + toppingCosts - 10000 <= 10000 - base 也就是大于一万方案可选的条件

对于2 * x + y <= C求x + y最值，用高中数学在直角坐标系上面画一下就出来了

x + y <= 20000故上限为20000

基料加两个辅料

base + toppingCosts * 2 - 10000 <= 10000 - base

同样的解得x + 2 * y <= 10000

取大者20000，故上限为20000

接下来就是0/1背包模板了，只不过我们要先把辅料给放进去

代码如下：

class Solution {
public:
const int maxn = 20000;
    int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) {
        //背包容量为20000
        bitset<20001> can;
        for(auto x : baseCosts)
        can[x] = 1;
        toppingCosts.insert(toppingCosts.end() , toppingCosts.begin() , toppingCosts.end());
        for(auto x : toppingCosts)
        for(int i = maxn ; i >= x ; i--)
        can[i] = can[i] || can[i - x];
        
        int res = maxn;
        for(int i = maxn ; i >= 0 ; i--)
        if(can[i] && abs(target - i) <= abs(target - res))
        {res = i;
        
        }
        return res;
    }
};

2212. 射箭比赛中的最大得分

F1：0/1背包

这道题联系到0/1背包是很不容易的，Bob能够射的箭的数量numArrows是给定了的，我们每次可以射可以不射，最后求最大得分，这其实就有点0/1背包的意思了

我们定义状态dp[ i ] [ j ]表示前i个区域，射j支箭可以获得的最大得分

而我们能够射的条件是j >= aliceArrows[i]，这个时候我们选择射aliceArrows[i] + 1支箭，保证射的最少还能拿分

当j >= aliceArrows[i]时

dp[i][j] = max(dp[i - 1] [j] , dp[i - 1] [j - a - 1] + i);

否则

dp[i] [j] = dp[i - 1] [j];

按照套路我们可能会想到去滚动数组优化，但是这道题目要求返回个区域射出箭的数目，所以我们还要遍历每个区域的得分，通过判断和前一个区域的最大得分的比较来判断是否在这个区域射了箭，其实就是一个路径恢复问题

如果这个区域射了箭，那么显然射aliceArrows[i] + 1支，我们箭的余量减去aliceArrows[i] + 1，这样倒序枚举一直枚举到第一个区域结束，最后剩余箭的数目就是第一个区域射的数目

代码如下：

class Solution {
public:
    vector<int> maximumBobPoints(int numArrows, vector<int>& aliceArrows) {
        vector<vector<int>> dp(12 , vector<int>(numArrows + 1 , 0));
        vector<int> ret(12 , 0);
        for(int i = 1 ; i < 12 ; i++)
        {
            int a = aliceArrows[i];
            for(int j = 1 ; j <= numArrows ; j++)
            {
                if(j >= a + 1)
                dp[i][j] = max(dp[i - 1][j] , dp[i - 1][j - a - 1] + i);
                else
                dp[i][j] = dp[i - 1][j];
            }
        }    
        for(int i = 11 ; i >= 1 ; i--)
        {
            if(dp[i][numArrows] > dp[i - 1][numArrows])
            {
                ret[i] = aliceArrows[i] + 1;
                numArrows -= ret[i];
            }
        }
        ret[0] = numArrows;
        return ret;
    }
};

F2：二进制枚举

1049. 最后一块石头的重量 II

本题可能想到是背包问题，但是会很难往背包上面去靠，我们要最后留下来的石头的最小重量，其实可以等效为两堆石头重量的最小差值，为什么呢？

根据我们题目的规则，每次拿出两个石头让他们的重量相减，如此重复，到最后一步只剩下两个石头，然后质量相减变为一个石头，我们仔细思考会发现假如有n块石头，最后剩下的重量其实是总质量减去n - 1块石头的重量和一块石头的部分重量，那么自然可以等效为两堆石头的质量相减，当然我们要保证两堆石头尽可能的接近sum/2，这样不会出现一堆石头过于重，使得相减之后其实剩余的重量其实还可以进行几块石头间的相减

那么假如我们有了两堆石头，保证了二者都尽可能的接近sum / 2，一堆是x，另一堆是sum - x，那么二者对于sum的差的绝对值都是2 / sum - x

而我们要的结果其实是sum - 2 * x

这样就可以等效为若干块总重sum重量的石头能往容量为sum / 2的背包里面放的最大重量

dp[ i ] [ j ] = max(dp[ i - 1 ] [ j ] , dp[ i - 1 ] [ j - stones[i] ])（令人熟悉的模板）

利用滚动数组优化则

dp[i] = max(dp[i - x] + x , dp[i]);

代码如下

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = accumulate(stones.begin() , stones.end() , 0);
        int target = sum / 2;
        vector<int> dp(target + 1);
        for(auto x : stones)
        for(int i = target ; i >= x ; i--)
        {
            dp[i] = max(dp[i - x] + x , dp[i]);
        }

        return sum - 2 * dp[target];
    }
};

474. 一和零

如何把问题转化为一个0/1背包问题呢？

这道题目与以往的0/1背包不同的地方是背包的维度是一个二维的背包

题目给我们规定了0和1的限制数目m和n，就是背包两个维度的容量，我们不妨定义dp[ i ] [ j ] [ k ]为前i个字符串放到总量为j个0和k个1中的最大字符串数量

我们只需要遍历字符串数组，然后枚举两个维度容量（顺序无所谓），然后套用模板即可

又因为根据滚动数组优化我们可以只保留容量维度，优化去i这个维度，于是有递推：

dp[ i ] [ j ] = max(dp[ i ] [ j ] , dp[ i - p ] [ j - q] + 1),（p和q分别为当前枚举字符串中0和1的个数）

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int sz = strs.size();
        vector<vector<int>> dp(m + 1 , vector<int>(n + 1));
        for(auto& x : strs)
        {
            int p = 0 , q = 0;
            for(auto ch : x)
            if(ch == '0')
            p++;
            else
            q++;
            
        for(int i = m ; i >= p ; i--)
        {
            for(int j = n ; j >= q ; j--)
            {
                dp[i][j] = max(dp[i][j] , dp[i - p][j - q] + 1);
            }
        }
        }
        return dp[m][n];
    }
};