每日一练：动态规划之（完全背包）03

西～西～

于 2024-09-22 17:43:44 发布

阅读量1.1k

点赞数 11

文章标签：动态规划算法

本文链接：https://blog.csdn.net/m0_74701193/article/details/142439268

版权

每日一练：动态规划之完全背包

1.完全背包

题目链接

https://www.nowcoder.com/share/jump/3971807151726994310126

题⽬描述

你有⼀个背包，最多能容纳的体积是 V。
现在有 n 种物品，每种物品有任意多个，第i种物品的体积为 vi,价值为 wi。（1）求这个背包⾄多能装多⼤价值的物品？
（2）若背包恰好装满，求⾄多能装多⼤价值的物品？

输⼊描述：
第⼀⾏两个整数 n 和 V，表⽰物品个数和背包体积。
接下来 n ⾏，每⾏两个数 vi 和 wi，表⽰第i种物品的体积和价值。
1 ≤ n,V ≤ 1000
输出描述：
输出有两⾏，第⼀⾏输出第⼀问的答案，第⼆⾏输出第⼆问的答案，如果⽆解请输出 0。

⽰例1
输⼊：2 6
5 10
3 1
输出：10
2
⽰例2
输⼊：3 8
3 10
9 1
10 1
输出：20
0
说明：⽆法恰好装满背包。
⽰例3
输⼊：6 13
13 189
17 360
19 870
14 184
6 298 16 242
输出：596
189
说明：可以装 5 号物品 2 个，达到最⼤价值 298*2=596，若要求恰好装满，只能装 1 个 1 号物品，
价值为189.

解法（动态规划）

算法思路

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

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][j2*v[i]]+2*w[i]...)

当我们发现，计算⼀个状态的时候，需要⼀个循环才能搞定的时候，我们要想到去优化。优化的⽅
向就是⽤⼀个或者两个状态来表⽰这⼀堆的状态，通常就是⽤数学的⽅式做⼀下等价替换。我们发
现第⼆维是有规律的变化的，因此我们去看看
dp[i][j - v[i]] 这个状态：

dp[i][j-v[i]]=max(dp[i-1][j-v[i]],dp[i-1][j-2*v[i]]+w[i],dp[i-1][j-3*v[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]) 。

3. 初始化：

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

4. 填表顺序：

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

5. 返回值：

根据状态表⽰，返回 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 。

3. 初始化：

我们多加⼀⾏，⽅便我们的初始化：

i. 第⼀个格⼦为 0 ，因为正好能凑⻬体积为 0 的背包；

ii. 但是第⼀⾏后⾯的格⼦都是 -1 ，因为没有物品，⽆法满⾜体积⼤于 0 的情况。

4. 填表顺序：

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

5. 返回值：

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

代码

public void main(String[] args) {
            Scanner in = new Scanner(System.in);
            int n = in.nextInt();
            int V = in.nextInt();
            int[] v = new int[n];
            int[] w = new int[n];
            for (int i = 0; i < n; i++) {
                v[i] = in.nextInt();
                w[i] = in.nextInt();
            }
            //多加一行，为了防止下标越界
            int[][] dp = new int[n + 1][V + 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 - 1] >= 0) {
                        dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - v[i - 1]] + w[i - 1]);
                    }
                }
            }
            System.out.println(dp[n][V]);


            int[][] dp1 = new int[n + 1][V + 1];
            for (int j = 1; j <= V; j++) {
                dp1[0][j] = -1;
            }

            for (int i = 1; i <= n; i++) {
                for (int j = 0; j <= V; j++) {
                    dp1[i][j] = dp1[i - 1][j];
                    if (j - v[i - 1] >= 0 && dp1[i - 1][j - v[i - 1]] != -1) {
                        dp1[i][j] = Math.max(dp1[i][j], dp1[i - 1][j - v[i - 1]] + w[i - 1]);
                    }
                }
            }
            if (dp1[n][V] == -1) {
                System.out.println(0);
            } else {
                System.out.println(dp1[n][V]);
            }


        }
    }

3. 零钱兑换

题⽬链接

https://leetcode.cn/problems/coin-change/description/

题⽬描述：

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

解法（动态规划）：

算法思路：

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

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] 。但是要特判⼀下，因为有可能凑不到。

代码

class Solution {
    public int coinChange(int[] coins, int amount) {

int n = coins.length, INF = 0x3f3f3f3f;
 int[][] dp = new int[n+1][amount+1];
 for(int j = 1; j <= amount; j++)dp[0][j] = INF;
 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]>= 0){
   
            dp[i][j] = Math.min(dp[i][j], dp[i][j - coins[i - 1]] + 1);
 }
    }
 }

 return dp[n][amount]>= INF?-1:dp[n][amount];
    }
}

2.零钱兑换II

题⽬链接

https://leetcode.cn/problems/coin-change-ii/description/

题⽬描述

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

解法（动态规划）：

算法思路：

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

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 *zcoins[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 即可。

3. 初始化：

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

4. 填表顺序：

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

5. 返回值：

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

代码

class Solution {
    public int change(int amount, int[] coins) {
        int n = coins.length;
        int[][] dp = new int[n+1][amount+1];
        dp[0][0]=1;
        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]>=0){
                    dp[i][j]+=dp[i][j-coins[i-1]];
                }
            }
        }
        return dp[n][amount];
    }
}

4. 完全平⽅数

题⽬链接

https://leetcode.cn/problems/perfect-squares/description/

题⽬描述

给你⼀个整数 n ，返回和为 n 的完全平⽅数的最少数量。
完全平⽅数是⼀个整数，其值等于另⼀个整数的平⽅；换句话说，其值等于⼀个整数⾃乘的积。例
如，1、4、9 和 16 都是完全平⽅数，⽽ 3 和 11 不是。
⽰例 1：
输⼊：n = 12
输出：3
解释：
12 = 4 + 4 + 4
⽰例 2：
输⼊：n = 13
输出：2
解释：
13 = 4 + 9

解法（动态规划）

算法思路：这⾥给出⼀个⽤「拆分出相同⼦问题」的⽅式，定义⼀个状态表⽰。（⽤「完全背包」⽅式的解法就仿照之前的分析模式就好啦~~）
为了叙述⽅便，把和为 n 的完全平⽅数的最少数量简称为「最⼩数量」。对于 12 这个数，我们分析⼀下如何求它的最⼩数量。

▪ 如果 12 本⾝就是完全平⽅数，我们不⽤算了，直接返回 1 ；

▪ 但是 12 不是完全平⽅数，我们试着把问题分解⼀下：

情况⼀：拆出来⼀个 1 ，然后看看 11 的最⼩数量，记为 x1 ；

情况⼆：拆出来⼀个 4 ，然后看看 8 的最⼩数量，记为 x2 ；（为什么拆出来 4 ，⽽不拆出来 2 呢？）

情况三：拆出来⼀个 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] 的值

代码

class Solution 
{
 public int numSquares(int n) 
 {
 int[] dp = new int[n + 1];
 dp[1] = 1; // 初始化 
 for(int i = 2; i <= n; i++) // 枚举每个数 
 {
 dp[i] = 1 + dp[i - 1]; // ⾄少等于 1 + dp[i - 1] 
 for(int j = 2; j * j <= i; j++) // ⽤⼩于 i 的完全平⽅数划分区间 
 dp[i] = Math.min(dp[i], dp[i - j * j] + 1); // 拿到所有划分区间内的

 }
 // 返回结果 
 return dp[n];
 }
}