代码随想录动态规划-完全背包问题

52. 携带研究材料

时间限制：1.000S 空间限制：128MB

题目描述

小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的重量，并且具有不同的价值。

小明的行李箱所能承担的总重量为 N，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料可以选择无数次，并且可以重复选择。

输入描述

第一行包含两个整数，N，V，分别表示研究材料的种类和行李空间

接下来包含 N 行，每行两个整数 wi 和 vi，代表第 i 种研究材料的重量和价值

输出描述

输出一个整数，表示最大价值。

输入示例

输出示例

提示信息

第一种材料选择五次，可以达到最大值。

数据范围：

1 <= N <= 10000;
1 <= V <= 10000;
1 <= wi, vi <= 10^9.

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。

完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。

同样leetcode上没有纯完全背包问题，都是需要完全背包的各种应用，需要转化成完全背包问题，所以我这里还是以纯完全背包问题进行讲解理论和原理。

01背包和完全背包唯一不同就是体现在遍历顺序上，所以本文就不去做动规五部曲了，我们直接针对遍历顺序经行分析！

首先再回顾一下01背包的核心代码

for(int i = 0; i < weight.size(); i++) { // 遍历物品for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);}
}

我们知道01背包内嵌的循环是从大到小遍历，为了保证每个物品仅被添加一次。

而完全背包的物品是可以添加多次的，所以要从小到大去遍历，即：

// 先遍历物品，再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);}
}

dp状态图如下：

动态规划-完全背包

import java.util.*;  public class Main {  public static void main(String[] args) {  // 创建一个Scanner对象，用于从标准输入（键盘）读取用户输入  Scanner sc = new Scanner(System.in);  // 从用户处读取背包的容量V和物品种类N  int N = sc.nextInt();  // N代表物品种类的数量  int V = sc.nextInt();  // V代表背包的最大容量  // 初始化两个数组，用于存储每种物品的价值和重量  int[] values = new int[N];  // values数组存储物品的价值  int[] weights = new int[N]; // weights数组存储物品的重量  // 循环读取每种物品的重量和价值，并存储在对应的数组中  for(int i = 0; i < N; i++) {  weights[i] = sc.nextInt(); // 读取第i个物品的重量  values[i] = sc.nextInt();  // 读取第i个物品的价值  }  // 初始化动态规划数组dp，用于存储不同容量背包下的最大价值  // dp数组的长度为V+1，因为背包的容量从0到V  int[] dp = new int[V + 1];  // 动态规划过程，计算每个容量下背包所能装入物品的最大价值  for(int i = 0; i < N; i++){    // 遍历每个物品  for(int j = 0; j <= V; j++){ // 遍历每个可能的背包容量  // 如果当前物品的重量小于等于当前背包容量  if(j >= weights[i]){  // 更新dp[j]，选择装入或不装入当前物品以获得最大价值  dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]);  }  // 如果当前物品重量大于背包容量，则跳过该物品，不更新dp[j]  }  }  // 输出dp数组中的最后一个元素，即背包容量为V时的最大价值  System.out.println(dp[V]);  // 关闭Scanner对象，释放资源  sc.close();  }  
}

518.零钱兑换II

518. 零钱兑换 II

中等

给你一个整数数组 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

动规五步曲来分析如下：

确定dp数组以及下标的含义

dp[j]：凑成总金额j的货币组合数为dp[j]

确定递推公式

dp[j] 就是所有的dp[j - coins[i]]（考虑coins[i]的情况）相加。

所以递推公式：dp[j] += dp[j - coins[i]];

这个递推公式大家应该不陌生了，我在讲解01背包题目的时候在这篇494. 目标和 (opens new window)中就讲解了，求装满背包有几种方法，公式都是：dp[j] += dp[j - nums[i]];

两者有相似之处，都是组合问题，不仅递推公式一样，对dp的初始化也一样

dp数组如何初始化

首先dp[0]一定要为1，dp[0] = 1是递归公式的基础。如果dp[0] = 0 的话，后面所有推导出来的值都是0了。

要凑成金额为0的话，只有一种组合方式就是什么也不放

确定遍历顺序

本题中我们是外层for循环遍历物品（钱币），内层for遍历背包（金钱总额），还是外层for遍历背包（金钱总额），内层for循环遍历物品（钱币）呢？

我在动态规划：关于完全背包，你该了解这些！ (opens new window)中讲解了完全背包的两个for循环的先后顺序都是可以的。

但本题就不行了！

因为纯完全背包求得装满背包的最大价值是多少，和凑成总和的元素有没有顺序没关系，即：有顺序也行，没有顺序也行！

而本题要求凑成总和的组合数，元素之间明确要求没有顺序。

所以纯完全背包是能凑成总和就行，不用管怎么凑的。

本题是求凑出来的方案个数，且每个方案个数是为组合数。

那么本题，两个for循环的先后顺序可就有说法了。

我们先来看外层for循环遍历物品（钱币），内层for遍历背包（金钱总额）的情况。

代码如下：

for (int i = 0; i < coins.size(); i++) { // 遍历物品for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量dp[j] += dp[j - coins[i]];}
}

假设：coins[0] = 1，coins[1] = 5。

那么就是先把1加入计算，然后再把5加入计算，得到的方法数量只有{1, 5}这种情况。而不会出现{5, 1}的情况。

所以这种遍历顺序中dp[j]里计算的是组合数！

如果把两个for交换顺序，代码如下：

for (int j = 0; j <= amount; j++) { // 遍历背包容量for (int i = 0; i < coins.size(); i++) { // 遍历物品if (j - coins[i] >= 0) dp[j] += dp[j - coins[i]];}
}

背包容量的每一个值，都是经过 1 和 5 的计算，包含了{1, 5} 和 {5, 1}两种情况。

此时dp[j]里算出来的就是排列数！

可能这里很多同学还不是很理解，建议动手把这两种方案的dp数组数值变化打印出来，对比看一看！（实践出真知）

先遍历物品后遍历背包是这样，比如，外层循环固定coins【1】，在内层循环遍历背包时，随着背包不断增加，coins【1】可以重复被添加进来，而由于外层循环固定了，因此coins【2】只能在下一次外层循环添加进不同大小的背包中，这么看的话，coins【i+1】只能在coins【i】之后了；如果先遍历背包后遍历物品，那么外层循环先固定背包大小j，然后在大小为j的背包中循环遍历添加物品，然后在下次外层循环背包大小变为j+1，此时仍要执行内层循环遍历添加物品，也就会出现在上一轮外层循环中添加coins【2】的基础上还能再添加coins【1】的情况，那么就有了coins【1】在coins【2】之后的情况了。

举例推导dp数组

输入: amount = 5, coins = [1, 2, 5] ，dp状态图如下：

518.零钱兑换II

最后红色框dp[amount]为最终结果。

class Solution {  public int change(int amount, int[] coins) {  // 初始化动态规划数组，dp[i]表示凑齐金额i的方法数  int[] dp = new int[amount + 1];  // 初始条件：凑齐金额为0的方法数为1（不选取任何硬币）  dp[0] = 1;  // 遍历每种硬币  for(int i = 0; i < coins.length; i++){  // 遍历每个金额  for(int j = 0; j <= amount; j++){  // 如果当前金额大于等于当前硬币的面值  if(j >= coins[i]){  // 更新dp[j]，加上使用当前硬币（dp[j - coins[i]]）和不使用当前硬币（dp[j]原值）的方法数  dp[j] += dp[j - coins[i]];  }  }  }  // 返回凑齐目标金额的方法数  return dp[amount];  }  
}

377.组合总和IV

377. 组合总和 Ⅳ

已解答

中等

322.零钱兑换

322. 零钱兑换

中等

给你一个整数数组 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

动规五部曲分析如下：

确定dp数组以及下标的含义

dp[j]：凑足总额为j所需钱币的最少个数为dp[j]

确定递推公式

凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）

所以dp[j] 要取所有 dp[j - coins[i]] + 1 中最小的。

递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);

dp数组如何初始化

首先凑足总金额为0所需钱币的个数一定是0，那么dp[0] = 0;

其他下标对应的数值呢？

考虑到递推公式的特性，dp[j]必须初始化为一个最大的数，否则就会在min(dp[j - coins[i]] + 1, dp[j])比较的过程中被初始值覆盖。

所以下标非0的元素都是应该是最大值。

代码如下：

vector<int> dp(amount + 1, INT_MAX);
dp[0] = 0;

确定遍历顺序

本题求钱币最小个数，那么钱币有顺序和没有顺序都可以，都不影响钱币的最小个数。

所以本题并不强调集合是组合还是排列。

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

在动态规划专题我们讲过了求组合数是动态规划：518.零钱兑换II (opens new window)，求排列数是动态规划：377. 组合总和 Ⅳ (opens new window)。

所以本题的两个for循环的关系是：外层for循环遍历物品，内层for遍历背包或者外层for遍历背包，内层for循环遍历物品都是可以的！

那么我采用coins放在外循环，target在内循环的方式。

本题钱币数量可以无限使用，那么是完全背包。所以遍历的内循环是正序

综上所述，遍历顺序为：coins（物品）放在外循环，target（背包）在内循环。且内循环正序。

举例推导dp数组

以输入：coins = [1, 2, 5], amount = 5为例

322.零钱兑换

dp[amount]为最终结果。

class Solution {  // 定义一个方法，用于计算最少需要的硬币数量以凑成给定金额  public int coinChange(int[] coins, int amount) {  // 创建一个动态规划数组dp，长度为amount+1 dp[i]表示凑成金额i所需的最少硬币数量。  int[] dp = new int[amount + 1];  // 初始化dp数组，将所有值设为Integer.MAX_VALUE，表示没有硬币状态下凑成任何金额都是不可能的。  for(int i = 0; i <= amount; i++){  dp[i] = Integer.MAX_VALUE;  }  // 凑成金额为0不需要任何硬币，所以dp[0]为0。  dp[0] = 0;  // 遍历硬币数组  for(int i = 0; i < coins.length; i++){  // 遍历从当前硬币面值到目标金额的所有可能金额  for(int j = coins[i]; j <= amount; j++){  // 如果dp[j - coins[i]]不是初始的不可达值，即存在一种方式凑成金额j - coins[i]  if(dp[j - coins[i]] != Integer.MAX_VALUE){  // 则我们可以尝试使用当前硬币面值coins[i]来凑成金额j，  // 并更新dp[j]为当前的最少硬币数量与dp[j - coins[i]] + 1中的较小值。  dp[j] = Math.min(dp[j - coins[i]] + 1, dp[j]);  }  }  }  // 如果dp[amount]仍然是最初的不可达值，说明无法凑成目标金额，返回-1；  // 否则返回dp[amount]，即凑成目标金额所需的最少硬币数量。  return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];  }  
}

279.完全平方数

279. 完全平方数

中等

给你一个整数 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

动规五部曲分析如下：

确定dp数组（dp table）以及下标的含义

dp[j]：和为j的完全平方数的最少数量为dp[j]

确定递推公式

dp[j] 可以由dp[j - i * i]推出， dp[j - i * i] + 1 便可以凑成dp[j]。

此时我们要选择最小的dp[j]，所以递推公式：dp[j] = min(dp[j - i * i] + 1, dp[j]);

dp数组如何初始化

dp[0]表示和为0的完全平方数的最小数量，那么dp[0]一定是0。

有同学问题，那0 * 0 也算是一种啊，为啥dp[0] 就是 0呢？

看题目描述，找到若干个完全平方数（比如 1, 4, 9, 16, ...），题目描述中可没说要从0开始，dp[0]=0完全是为了递推公式。

非0下标的dp[j]应该是多少呢？

从递归公式dp[j] = min(dp[j - i * i] + 1, dp[j]);中可以看出每次dp[j]都要选最小的，所以非0下标的dp[j]一定要初始为最大值，这样dp[j]在递推的时候才不会被初始值覆盖。

确定遍历顺序

我们知道这是完全背包，

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

在动态规划：322. 零钱兑换 (opens new window)中我们就深入探讨了这个问题，本题也是一样的，是求最小数！

所以本题外层for遍历背包，内层for遍历物品，还是外层for遍历物品，内层for遍历背包，都是可以的！

我这里先给出外层遍历背包，内层遍历物品的代码：

vector<int> dp(n + 1, INT_MAX);
dp[0] = 0;
for (int i = 0; i <= n; i++) { // 遍历背包for (int j = 1; j * j <= i; j++) { // 遍历物品dp[i] = min(dp[i - j * j] + 1, dp[i]);}
}

举例推导dp数组

已输入n为5例，dp状态图如下：

279.完全平方数

dp[0] = 0 dp[1] = min(dp[0] + 1) = 1 dp[2] = min(dp[1] + 1) = 2 dp[3] = min(dp[2] + 1) = 3 dp[4] = min(dp[3] + 1, dp[0] + 1) = 1 dp[5] = min(dp[4] + 1, dp[1] + 1) = 2

最后的dp[n]为最终结果。

class Solution {  // 定义一个方法，用于计算将一个正整数表示为完全平方数的最少数量  public int numSquares(int n) {  // 创建一个动态规划数组dp，长度为n+1。dp[i]表示凑成整数i所需的最少完全平方数数量。  int[] dp = new int[n + 1];  // 初始化一个很大的数，用于标记未计算的状态  int max = Integer.MAX_VALUE;  // 初始化dp数组，将所有值设为max，表示初始状态下凑成任何整数都是不可能的。  for(int i = 0; i <= n ; i++){  dp[i] = max;  }  // 凑成整数0不需要任何完全平方数，所以dp[0]为0。  dp[0] = 0;  // 遍历可能的完全平方数（从1的平方开始，直到其平方大于n）  for(int i = 1; i * i <= n; i++){  // 遍历从当前完全平方数到n的所有整数  for(int j = i * i; j <= n; j++){  // 如果dp[j - i * i]不是初始的不可达值，即存在一种方式凑成整数j - i * i  if(dp[j - i * i] != max){  // 则我们可以尝试使用当前完全平方数i * i来凑成整数j，  // 并更新dp[j]为当前的最少完全平方数数量与dp[j - i * i] + 1中的较小值。  dp[j] = Math.min(dp[j], dp[j - i * i] + 1);  }  }  }  // 返回dp[n]，即凑成整数n所需的最少完全平方数数量。  return dp[n];  }  
}

139.单词拆分

139. 单词拆分

中等

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。注意，你可以重复使用字典中的单词。

示例 3：

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出: false

提示：

1 <= s.length <= 300
1 <= wordDict.length <= 1000
1 <= wordDict[i].length <= 20
s 和 wordDict[i] 仅由小写英文字母组成
wordDict 中的所有字符串 互不相同

动规五部曲分析如下：

确定dp数组以及下标的含义

dp[i] : 字符串长度为i的话，dp[i]为true，表示可以拆分为一个或多个在字典中出现的单词。

确定递推公式

如果确定dp[j] 是true，且 [j, i] 这个区间的子串出现在字典里，那么dp[i]一定是true。（j < i ）。

所以递推公式是 if([j, i] 这个区间的子串出现在字典里 && dp[j]是true) 那么 dp[i] = true。

dp数组如何初始化

从递推公式中可以看出，dp[i] 的状态依靠 dp[j]是否为true，那么dp[0]就是递推的根基，dp[0]一定要为true，否则递推下去后面都都是false了。

那么dp[0]有没有意义呢？

dp[0]表示如果字符串为空的话，说明出现在字典里。

但题目中说了“给定一个非空字符串 s” 所以测试数据中不会出现i为0的情况，那么dp[0]初始为true完全就是为了推导公式。

下标非0的dp[i]初始化为false，只要没有被覆盖说明都是不可拆分为一个或多个在字典中出现的单词。

确定遍历顺序

题目中说是拆分为一个或多个在字典中出现的单词，所以这是完全背包。

还要讨论两层for循环的前后顺序。

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

我在这里做一个总结：

求组合数：动态规划：518.零钱兑换II (opens new window)求排列数：动态规划：377. 组合总和 Ⅳ (opens new window)、动态规划：70. 爬楼梯进阶版（完全背包） (opens new window)求最小数：动态规划：322. 零钱兑换 (opens new window)、动态规划：279.完全平方数(opens new window)

而本题其实我们求的是排列数，为什么呢。拿 s = "applepenapple", wordDict = ["apple", "pen"] 举例。

"apple", "pen" 是物品，那么我们要求物品的组合一定是 "apple" + "pen" + "apple" 才能组成 "applepenapple"。

"apple" + "apple" + "pen" 或者 "pen" + "apple" + "apple" 是不可以的，那么我们就是强调物品之间顺序。

所以说，本题一定是先遍历背包，再遍历物品。

举例推导dp[i]

以输入: s = "leetcode", wordDict = ["leet", "code"]为例，dp状态如图：

139.单词拆分

dp[s.size()]就是最终结果。

public class Solution {  public boolean wordBreak(String s, List<String> wordDict) {  // 将单词列表转换为HashSet，方便快速查找  HashSet<String> wordSet = new HashSet<>(wordDict);  // 创建一个布尔值数组dp，dp[i]表示字符串s的前i个字符是否可以拆分成若干个单词  boolean[] dp = new boolean[s.length() + 1];  // 初始化dp[0]为true，表示空字符串可以被拆分成0个单词  dp[0] = true;  // 遍历字符串s的每个位置（从1到s的长度）  for (int i = 1; i <= s.length(); i++) {  // 遍历当前位置之前的所有位置，尝试找到可能的单词拆分  for (int j = 0; j < i; j++) {  // 截取从位置j到位置i的子字符串  String word = s.substring(j, i);  // 如果子字符串在单词集合中，并且子字符串之前的部分也可以被拆分成单词  if (wordSet.contains(word) && dp[j]) {  // 则标记当前位置i也可以被拆分成单词  dp[i] = true;  // 找到一个可能的拆分后，就可以跳出内层循环，因为不需要继续尝试更短的子字符串  break;  }  }  }  // 返回整个字符串s是否可以被拆分成单词  return dp[s.length()];  }  
}