专题九：完全背包问题

lvo
111 阅读13分钟

1 完全背包

1.1 题目链接

完全背包

1.2 题目描述

image.png

1.3 解法（动态规划）

算法思路：

背包问题的状态表⽰⾮常经典，如果⼤家不知道怎么来的，就把它当成⼀个模板记住吧~

我们先解决第⼀问：

  1. 状态表⽰：

    dp[i][j] 表⽰：从前 i 个物品中挑选，总体积不超过 j ，所有的选法中，能挑选出来的最⼤价值。（这⾥是和 01背包⼀样哒）

  2. 状态转移⽅程：

  • 线性 dp 状态转移⽅程分析⽅式，⼀般都是根据最后⼀步的状况，来分情况讨论。但是最后⼀个物品能选很多个，因此我们的需要分很多情况：
    • i. 选 0 个第 i 个物品：此时相当于就是去前 i - 1 个物品中挑选，总体积不超过 j 。
      • 此时最⼤价值为 dp[i - 1][j] ；
    • ii. 选 1 个第 i 个物品：此时相当于就是去前 i - 1 个物品中挑选，总体积不超过 j - v[i] 。因为挑选了⼀个 i 物品，此时最⼤价值为 dp[i - 1][j - v[i]] + w[i]
    • iii.选 2 个第 i 个物品：此时相当于就是去前 i - 1 个物品中挑选，总体积不超过 j - 2 * v[i] 。因为挑选了两个 i 物品，此时最⼤价值为 dp[i - 1][j - 2 *v[i]] + 2 * w[i] ；
    • iv. ......
  • 综上，我们的状态转移⽅程为：
    • dp[i][j]=max(dp[i-1][j], dp[i-1][j-v[i]]+w[i], dp[i-1][j-2v[i]]+2w[i]...)
  • 当我们发现，计算⼀个状态的时候，需要⼀个循环才能搞定的时候，我们要想到去优化。优化的⽅向就是⽤⼀个或者两个状态来表⽰这⼀堆的状态，通常就是⽤数学的⽅式做⼀下等价替换。我们发现第⼆维是有规律的变化的，因此我们去看看 dp[i][j - v[i]] 这个状态：
    • dp[i][j-v[i]]=max(dp[i-1][j-v[i]],dp[i-1][j-2v[i]]+w[i],dp[i-1][j-3v[i]]+2*w[i]...)
  • 我们发现，把 dp[i][j - v[i]] 加上 w[i] 正好和 dp[i][j] 中除了第⼀项以外的全部⼀致，因此我们可以修改我们的状态转移⽅程为：
    • dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i]) 。

  1. 初始化：

    我们多加⼀⾏，⽅便我们的初始化，此时仅需将第⼀⾏初始化为 0 即可。因为什么也不选，也能满⾜体积不⼩于 j 的情况，此时的价值为 0 。

  2. 填表顺序：

    根据状态转移⽅程，我们仅需从上往下填表即可。

  3. 返回值：

    根据状态表⽰，返回 dp[n][V] 。

接下来解决第⼆问：

  • 第⼆问仅需微调⼀下 dp 过程的五步即可。
    • 因为有可能凑不⻬ j 体积的物品，因此我们把不合法的状态设置为 -1 。

  1. 状态表⽰：

    dp[i][j] 表⽰：从前 i 个物品中挑选，总体积正好等于 j ，所有的选法中，能挑选出来的最⼤价值。

  2. 状态转移⽅程：

  • dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i]) 。
  • 但是在使⽤ dp[i][j - v[i]] 的时候，不仅要判断 j >= v[i] ，⼜要判断 dp[i][j -v[i]] 表⽰的情况是否存在，也就是 dp[i][j - v[i]] != -1 。
  1. 初始化：
  • 我们多加⼀⾏，⽅便我们的初始化：
    • i. 第⼀个格⼦为 0 ，因为正好能凑⻬体积为 0 的背包；
    • ii. 但是第⼀⾏后⾯的格⼦都是 -1 ，因为没有物品，⽆法满⾜体积⼤于 0 的情况。

  1. 填表顺序：

    根据状态转移⽅程，我们仅需从上往下填表即可。

  2. 返回值：

    由于最后可能凑不成体积为 V 的情况，因此返回之前需要特判⼀下。

空间优化：

  • 背包问题基本上都是利⽤滚动数组来做空间上的优化：
    • i. 利⽤滚动数组优化；
    • ii. 直接在原始代码上修改。
  • 在完全背包问题中，优化的结果为：
    • i. 仅需删掉所有的横坐标。

1.4 C++算法代码：

优化前的算法代码：

#include <iostream>
#include <string.h>
using namespace std;

const int N = 1001;
int n, V, v[N], w[N];
int dp[N][N];

int main()
{
    // 读入数据  背包可容纳物品个数n 体积V
    cin >> n >> V;
    // 依次读入  物品所需体积v[i] 价值w[i]
    for(int i = 1; i <= n; i++)
        cin >> v[i] >> w[i];
    
    // 第一问
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= V; j++)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i])
                dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
        }
    }
    cout << dp[n][V] <<endl;

    // 第二问
    memset(dp, 0, sizeof(dp));
    for(int j = 1; j <= V; j++) dp[0][j] = -1;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 0; j <= V; j++)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i] && dp[i][j - v[i]] != -1)
                dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
        }
    }
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]);
    return 0;
}

优化后的算法代码：

#include <iostream>
#include <string.h>
using namespace std;

const int N = 1001;
int n, V, v[N], w[N];
int dp[N];

int main()
{
    // 读入数据  背包可容纳物品个数n 体积V
    cin >> n >> V;
    // 依次读入  物品所需体积v[i] 价值w[i]
    for(int i = 1; i <= n; i++)
        cin >> v[i] >> w[i];
    
    // 第一问
    for(int i = 1; i <= n; i++)
        for(int j = v[i]; j <= V; j++)
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
    cout << dp[V] <<endl;

    // 第二问
    memset(dp, 0, sizeof(dp));
    for(int j = 1; j <= V; j++) dp[j] = -0x3f3f3f3f;
    for(int i = 1; i <= n; i++)
        for(int j = v[i]; j <= V; j++)
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);

    cout << (dp[V] < 0 ? 0 : dp[V]);
    return 0;
}

2 零钱兑换

2.1 题目链接

322. 零钱兑换

2.2 题目描述

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

 

示例 1：

输入： coins = [1, 2, 5], amount = 11
输出： 3 
解释： 11 = 5 + 5 + 1

示例 2：

输入： coins = [2], amount = 3
输出： -1

示例 3：

输入： coins = [1], amount = 0
输出： 0

 

提示：

  • 1 <= coins.length <= 12
  • 1 <= coins[i] <= 231 - 1
  • 0 <= amount <= 104

2.3 解法（动态规划）

算法思路：

先将问题「转化」成我们熟悉的题型。

  • i. 在⼀些物品中「挑选」⼀些出来，然后在满⾜某个「限定条件」下，解决⼀些问题，⼤概率是「背包」模型；
  • ii. 由于每⼀个物品都是⽆限多个的，因此是⼀个「完全背包」问题。接下来的分析就是基于「完全背包」的⽅式来的。

  1. 状态表⽰：

    dp[i][j] 表⽰：从前 i 个硬币中挑选，总和正好等于 j ，所有的选法中，最少的硬币个数。

  2. 状态转移⽅程：

    • 线性 dp 状态转移⽅程分析⽅式，⼀般都是根据「最后⼀步」的状况，来分情况讨论。但是最后⼀个物品能选很多个，因此我们的需要分很多情况：
      • i. 选 0 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j 。
        • 此时最少的硬币个数为 dp[i - 1][j] ；
      • ii. 选 1 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j - v[i] 。因为挑选了⼀个 i 硬币，此时最少的硬币个数为 dp[i - 1][j - coins[i]] + 1 ；
      • iii. 选 2 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j - 2 * coins 。因为挑选了两个 i 硬币，此时最少的硬币个数为 dp[i - 1][j - 2 * coins[i]] + 2 ；
      • iv. ......
    • 结合我们在完全背包⾥⾯的优化思路，我们最终得到的状态转移⽅程为：
      • dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i]] + 1) 。
    • 这⾥教给⼤家⼀个技巧，就是相当于把第⼆种情况 dp[i - 1][j - coins[i]] + 1 ⾥⾯的 i - 1 变成 i 即可。

  3. 初始化：

    • 初始化第⼀⾏即可。
    • 这⾥因为取 min ，所以我们可以把⽆效的地⽅设置成⽆穷⼤ (0x3f3f3f3f)
    • 因为这⾥要求正好凑成总和为 j ，因此，需要把第⼀⾏除了第⼀个位置的元素，都设置成⽆穷⼤。

  4. 填表顺序：

    根据「状态转移⽅程」，我们仅需「从上往下」填表即可。

  5. 返回值：

    根据「状态表⽰」，返回 dp[n][V] 。但是要特判⼀下，因为有可能凑不到。

2.4 C++算法代码：

优化前的算法代码：

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        const int INF = 0x3f3f3f3f;
        int n = coins.size();
        vector<vector<int>> dp(n + 1,vector<int>(amount + 1, INF));
        dp[0][0] = 0;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 0; j <= amount; j++)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= coins[i - 1])
                    dp[i][j] = min(dp[i][j], dp[i][j - coins[i - 1]] + 1);
            }
        }
        return dp[n][amount] >= INF ? -1 : dp[n][amount];
    }
};

空间优化后的算法代码：

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        const int INF = 0x3f3f3f3f;
        int n = coins.size();
        vector<int> dp (amount + 1, INF);
        dp[0] = 0;
        for(int i = 1; i <= n; i++)
            for(int j = coins[i - 1]; j <= amount; j++)
                dp[j] = min(dp[j], dp[j - coins[i - 1]] + 1);
        return dp[amount] >= INF ? -1 : dp[amount];
    }
};

3 零钱兑换 II

3.1 题目链接

518. 零钱兑换 II

3.2 题目描述

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。 

题目数据保证结果符合 32 位带符号整数。

 

示例 1：

输入： amount = 5, coins = [1, 2, 5]
输出： 4
解释： 有四种方式可以凑成总金额：
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

示例 2：

输入： amount = 3, coins = [2]
输出： 0
解释： 只用面额 2 的硬币不能凑成总金额 3 。

示例 3：

输入： amount = 10, coins = [10] 
输出： 1

 

提示：

  • 1 <= coins.length <= 300
  • 1 <= coins[i] <= 5000
  • coins 中的所有值 互不相同
  • 0 <= amount <= 5000

3.3 解法（动态规划）

算法思路：

先将问题「转化」成我们熟悉的题型。

  • i. 在⼀些物品中「挑选」⼀些出来，然后在满⾜某个「限定条件」下，解决⼀些问题，⼤概率是背包模型；
  • ii. 由于每⼀个物品都是⽆限多个的，因此是⼀个「完全背包」问题。
  • 接下来的分析就是基于「完全背包」的⽅式来的。

  1. 状态表⽰：

    dp[i][j] 表⽰：从前 i 个硬币中挑选，总和正好等于 j ，⼀共有多少种选法。

  2. 状态转移⽅程：

  • 线性 dp 状态转移⽅程分析⽅式，⼀般都是「根据最后⼀步」的状况，来分情况讨论。但是最后⼀个物品能选很多个，因此我们的需要分很多情况：
    • i. 选 0 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j 。
      • 此时最少的硬币个数为 dp[i - 1][j] ；
    • ii. 选 1 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j - v[i] 。因为挑选了⼀个 i 硬币，此时最少的硬币个数为 dp[i - 1][j - coins[i]] + 1 ；
    • iii. 选 2 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j - 2 * coins 。因为挑选了两个 i 硬币，此时最少的硬币个数为 dp[i - 1][j - 2 * coins[i]] + 2 ；
    • iv. ......
  • 结合我们在完全背包⾥⾯的「优化思路」，我们最终得到的状态转移⽅程为：
    • dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i]] + 1 。
  • 这⾥教给⼤家⼀个技巧，就是相当于把第⼆种情况 dp[i - 1][j - coins[i]] + 1 ⾥⾯的 i - 1 变成 i 即可。

  1. 初始化：

    • 初始化第⼀⾏即可。
    • 第⼀⾏表⽰没有物品，没有物品正好能凑能和为 0 的情况。因此 dp[0][0] = 1 ，其余位置都是 0 种情况。

  2. 填表顺序：

    根据「状态转移⽅程」，我们仅需「从上往下」填表即可。

  3. 返回值：

    根据「状态表⽰」，返回 dp[n][V] 。

3.4 C++算法代码：

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount + 1);
        dp[0] = 1;
        for(int e : coins)
            for(int i = e; i <= amount; i++)
                dp[i] += dp[i - e];
        return dp[amount];
    }
};

4 完全平方数

4.1 题目链接

279. 完全平方数

4.2 题目描述

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

 

示例 1：

输入： n = 12
输出： 3 
解释： 12 = 4 + 4 + 4

示例 2：

输入： n = 13
输出： 2
解释： 13 = 4 + 9

 

提示：

  • 1 <= n <= 104

4.3 解法（动态规划）

算法思路：

这⾥给出⼀个⽤「拆分出相同⼦问题」的⽅式，定义⼀个状态表⽰。（⽤「完全背包」⽅式的解法就仿照之前的分析模式就好啦~）

  • 为了叙述⽅便，把和为 n 的完全平⽅数的最少数量简称为「最⼩数量」。
  • 对于 12 这个数，我们分析⼀下如何求它的最⼩数量。
    • 如果 12 本⾝就是完全平⽅数，我们不⽤算了，直接返回 1 ；
    • 但是 12 不是完全平⽅数，我们试着把问题分解⼀下：
        1. 情况⼀：拆出来⼀个 1 ，然后看看 11 的最⼩数量，记为 x1 ；
        1. 情况⼆：拆出来⼀个 4 ，然后看看 8 的最⼩数量，记为 x2 ；（为什么拆出来 4 ，⽽不拆出来 2 呢？）
        1. 情况三：拆出来⼀个 8 ......
        • 其中，我们接下来求 11、8 的时候，其实⼜回到了原来的问题上。
  • 因此，我们可以尝试⽤ dp 的策略，将 1 2 3 4 6 等等这些数的最⼩数量依次保存起来。再求较⼤的 n 的时候，直接查表，然后找出最⼩数量。

  1. 状态表⽰：

    dp[i] 表⽰：和为 i 的完全平⽅数的最少数量。

  2. 状态转移⽅程：

    • 对于 dp[i] ，根据思路那⾥的分析我们知道，可以根据⼩于等于 i 的所有完全平⽅数 x 进⾏划分：
      • x = 1 时，最⼩数量为： 1 + dp[i - 1] ；
      • x = 4 时，最⼩数量为： 1 + dp[i - 4] ......
    • ⼀直枚举到 x <= i 为⽌。
    • 为了⽅便枚举完全平⽅数，我们采⽤下⾯的策略： for(int j = 1; j * j <= i; j++)
    • 综上所述，状态转移⽅程为：
      • dp[i] = min(dp[i], dp[i - j * j] + 1)

  3. 初始化：

    • 当 n = 0 的时候，没法拆分，结果为 0 ；
    • 当 n = 1 的时候，显然为 1 。

  4. 填表顺序：

    从左往右。

  5. 返回值：

    根据题意，返回 dp[n] 的值。

4.4 C++算法代码：

class Solution {
public:
    int numSquares(int n) {
        int m = sqrt(n);
        vector<int> dp(n + 1, 0x3f3f3f3f);
        dp[0] = 0;
        for(int i = 1; i <= m; i++)
            for(int j = i * i; j <= n; j++)
                dp[j] = min(dp[j], dp[j - i * i] + 1);
        return dp[n];
    }
};
avatar
文章
阅读
粉丝