动态规划——01背包

1. 经典“01背包”
2. “01背包”方法归纳
3. 实战
- 3.1 分割等和子集
- 3.2 最后一块石头的重量 II
- 3.3 目标和
- 3.4 一和零
- 3.5 盈利计划
参考

1. 经典“01背包”

经典的“01背包”问题描述如下：有 N 件物品和一个最多能被重量为 W 的背包。第i件物品的重量是 weight[i]，得到的价值是 value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

动归五部曲分析一下：

确定 dp 数组及下标的含义

dp[j] 表示背包容量为 j 时，能获得的最大价值。（这里直接省略二维数组直接进行一维数组的讲解）

确定递推公式

根据第一步 dp 数组的定义可知，当我们遍历到第 i 个物品时，可以选择将第 i 个物品装入背包，也可以选择不装，这两种情况分别所对应的最大价值如下：
- 装入：dp[j] = dp[j - weight[i]] + value[i] —— 如果装入第 i 个物品，则在装入之前需要背包先空出第 i 个物品的容量 weight[i]，此时背包所获的的最大价值为 dp[j - weight[i]]，然后再加上第 i 个物品的价值 value[i]
- 不装：dp[j] = dp[j] —— 如果不装入第 i 个物品，就用除第 i 个物品之外的其它物品填满容量为 j 的背包，此时的最大价值就是 dp[j]
最终 dp[j] 取装入或者不装入第 i 个物品所获得的价值中最大的那个，即dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

初始化

初始化是严格按照dp 数组的定义来的，当 j 为0时，背包的容量为0，所能获取的最大价值 dp[j] 也是0

确定遍历顺序

为了方便理解，也为了与 “01背包” 物品只能取一次的限定吻合，我们外层遍历物品，内层倒序遍历背包容量。这里为什么要倒序遍历背包容量呢？由递推公式 dp[j] = max(dp[j], dp[j - weight[i]] + value[i]) 可知，我们在计算大容量 dp[j] 时，需要用到小容量 dp[j - weight[i]] 的值，如果在更新大容量之前改变了小容量的值，那么最终的大容量肯定也会受影响，所以我们选择将容量从大到小遍历。

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]);}
}

举例推导 dp 数组

假如背包的容量为4，物品的重量和价值如下表：

物品	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

整体代码示例：

public static void testWeightBagProblem(int[] weight, int[] value, int bagWeight){int wLen = weight.length;//定义dp数组：dp[j]表示背包容量为j时，能获得的最大价值int[] dp = new int[bagWeight + 1];//遍历顺序：先遍历物品，再遍历背包容量for (int i = 0; i < wLen; i++){for (int j = bagWeight; j >= weight[i]; j--){dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);}}//打印dp数组for (int j = 0; j <= bagWeight; j++){System.out.print(dp[j] + " ");}
}

2. “01背包”方法归纳

其实“01背包”问题最难的是将原问题转化到“01背包”这个模型上来，然后再按照“01背包”的套路进行解题。一般遇到以下问题，优先考虑“01背包”：一堆东西（一组数），按照一定的方式进行组合、处理，能否凑成某种最值状态，或者凑成某种状态的方法数。

通用的动归5部曲：

dp 数组的定义：int[] dp = new int[bagSize];
dp[j] 递推公式：
- 如果求背包能装的最大重量：dp[j] = Math.max(dp[j], dp[j - nums[i]]);
- 如果求装满容量为 j 的背包的方法数：dp[j] = dp[j] + dp[j - nums[i]];
dp 数组初始化，按照dp 数组的定义对一些边界值进行初始化
遍历顺序：物品正序，背包倒序（防止物品多次放入）
举例推导 dp 数组，验证前四步的正确性

3. 实战

3.1 分割等和子集

LeetCode链接：416. 分割等和子集

给你一个只包含正整数的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
示例 1：
输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。
示例 2：
输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。
提示：
1 <= nums.length <= 200
1 <= nums[i] <= 100

思路：假设原数组内数字总和为 sum，若分成两个子集的元素和相等，则每个子集和为 sum / 2，该问题转化为“是否能从非空数组 nums 中选出一些数，这些数的和能够达到sum / 2 “。这就有点”01背包“内味了，我们想想背包问题的原意是求背包能装的最大价值，那转化到这道题上，如果组成子集的元素和最大为sum / 2 是不是也可以呢？当然可以！那就按照动归五步曲来了：

定义 dp 数组：dp[j] 表示容量为 j 的子集，和最大为 dp[j]。
递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]) 假设当子集的容量为 j 时，此时遍历到数组的第 i 个数，那我们有两种选择：
- 第一个选择：将第 i 个数字加入子集：此时能得到的最大和等于容量为 j - nums[i] 的子集能获得的最大价值加上 第 i 个数字的价值，即 dp[j - nums[i]] + nums[i]
- 第二个选择：不将第 i 个数字加入子集：保持现有的最大和 dp[j] （可以想象成物品太大，无法装入背包，背包内的价值保持原样）
- 综合上述两种情况，则 dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
确定初始值：初始化的时候一定要从 dp 数组的定义出发，选择一些不能通过递推公式得到或者递推公式所依赖的那些值（边界值）进行初始化。比如该题中，当子集容量为0的时候，子集内元素最大和也为0，即 dp[0] = 0
确定递推顺序：由于我们已经降维成一维数组，所以子集容量需要从大到小遍历，防止上一层的 dp[j - nums[i]] 被修改。这里想不明白的同学，建议手动画下递推数组。
举例推导 dp 数组

代码如下：

public boolean canPartition(int[] nums) {int sum = 0;for (Integer num : nums) {sum += num;}// 和为奇数，不能分为两个和一样的子集if ((sum & 1) == 1) return false;int target = sum / 2;// dp[j] 容量为j的子集所能凑成的最大和int[] dp = new int[target + 1];// 数组中的数字一个一个填，背包一点一点扩大for (int i = 0; i < nums.length; i++) {for (int j = target; j >= nums[i]; j--) {dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);// 找到结果提前返回if (dp[target] == target) return true;}}return false;
}

3.2 最后一块石头的重量 II

LeetCode链接：1049. 最后一块石头的重量 II

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。
每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

思路：题目说的是从一堆石头中每次拿出两颗进行碰撞（碰撞完剩余 |x-y| 的重量），直至最终剩余的石头重量最小。那我们是否可以将这一堆石头分成重量尽可能相等的两堆，然后直接拿这两堆石头进行碰撞，效果是不是和每次只拿两块石头碰撞一样？答案是肯定的！所以问题就转化为求石头能分为尽可能相等的两堆的重量，我们索性就用容量为 sum / 2 的背包去装石头，看最多能装多少，那么剩余的石头与背包内的石头相碰撞，剩余的重量就为最少。看，我们又把问题转化为 “0-1 背包” 问题了。动归五部曲如下：

定义 dp 数组：dp[j] 表示容量为 j 的背包，能装的石头最重的重量为 dp[j]。
递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]) 假设当背包的容量为 j 时，此时遍历到石头堆的第 i 个石头，我们有两种选择：
- 第一个选择：将第 i 个石头加入背包：此时能得到的最大重量等于容量为 j - nums[i] 的背包能获得的最大重量加上 第 i 个石头的重量，即 dp[j - nums[i]] + nums[i]
- 第二个选择：不将第 i 个石头加入背包：保持现有的最大重量 dp[j] （可以想象成石头太重，无法装入背包，背包内的重量保持原样）
- 综合上述两种情况，则 dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
确定初始值：初始化的时候一定要从 dp 数组的定义出发，选择一些不能通过递推公式得到或者递推公式所依赖的那些值（边界值）进行初始化。比如该题中，当背包容量为0的时候，背包内最终重量也为0，即 dp[0] = 0
确定递推顺序：由于我们已经降维成一维数组，所以背包容量需要从大到小遍历，防止上一层的 dp[j - nums[i]] 被修改。这里想不明白的同学，建议手动画下递推数组。
举例推导 dp 数组

代码

class Solution {public int lastStoneWeightII(int[] stones) {// 两堆石头尽可能同样重，这样碰撞之后剩余的重量才会尽可能小if (stones == null || stones.length == 0) {throw new IllegalArgumentException();}int sum = Arrays.stream(stones).sum();int target = sum / 2;// dp[j] 表示容量为 j 的背包能装的最大石头重量// dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i])int[] dp = new int[target + 1];// dp[0] = 0;for (int stone : stones) {for (int j = target; j >= stone; j--) {dp[j] = Math.max(dp[j], dp[j - stone] + stone);}}// 最终一堆石头的重量为 dp[target]，另一堆石头的重量为 sum - dp[target]，它们碰撞完剩余的重量为 sum - dp[target] * 2return sum - (dp[target] << 1);}
}

时间复杂度：O(N * Sum)
空间复杂度：O(Sum)

3.3 目标和

LeetCode链接：494. 目标和

给你一个整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个表达式：
例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。返回可以通过上述方法构造的、运算结果等于 target 的不同表达式的数目。
示例 1：
输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
示例 2：
输入：nums = [1], target = 1
输出：1
提示：
1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 1000

3.4 一和零

LeetCode链接：474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。
如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。
示例 1：
输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4 。
其他满足题意但较小的子集包括 {“0001”,“1”} 和 {“10”,“1”,“0”} 。{“111001”} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。
示例 2：
输入：strs = [“10”, “0”, “1”], m = 1, n = 1
输出：2
解释：最大的子集是 {“0”, “1”} ，所以答案是 2 。
提示：
1 <= strs.length <= 600
1 <= strs[i].length <= 100
strs[i] 仅由 ‘0’ 和 ‘1’ 组成
1 <= m, n <= 100

3.5 盈利计划

LeetCode链接：879. 盈利计划

集团里有 n 名员工，他们可以完成各种各样的工作创造利润。
第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与。如果成员参与了其中一项工作，就不能参与另一项工作。
工作的任何至少产生 minProfit 利润的子集称为盈利计划。并且工作的成员总数最多为 n 。
有多少种计划可以选择？因为答案很大，所以返回结果模 10^9 + 7 的值。
示例 1：
输入：n = 5, minProfit = 3, group = [2,2], profit = [2,3]
输出：2
解释：至少产生 3 的利润，该集团可以完成工作 0 和工作 1 ，或仅完成工作 1 。
总的来说，有两种计划。
示例 2：
输入：n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]
输出：7
解释：至少产生 5 的利润，只要完成其中一种工作就行，所以该集团可以完成任何工作。
有 7 种可能的计划：(0)，(1)，(2)，(0,1)，(0,2)，(1,2)，以及 (0,1,2) 。
提示：
1 <= n <= 100
0 <= minProfit <= 100
1 <= group.length <= 100
1 <= group[i] <= 100
profit.length == group.length
0 <= profit[i] <= 100

参考

代码随想录

动态规划——01背包相关推荐

算法分析-动态规划-01背包
在M件物品取出若干件放在空间为W的背包里,每件物品的体积为W1,W2--Wn,与之相对应的价值为P1,P2--Pn.求出获得最大价值的方案. 注意:在本题中,所有的体积值均为整数.01的意思是,每个物 ...
动态规划—0-1背包
动态规划有以下三个特点: 1:多阶段决策 2:最优值和最优解 3:最优子结构动态规划采用自底而上的思想保存子问题值,避免重复计算.例如斐波那契数列的递归函数,f(5)=f(3)+f(4),而f(4) ...
动态规划01背包算法详解
动态规划算法核心思想: 将大的问题转化为小问题进行解决. 01背包问题: 01背包是在M件物品取出若干件放在空间为W的背包里,每件物品的重量为W1,W2至Wn,与之相对应的价值为V1V2至Vn.01背 ...
c++ 动态规划-01背包
动态规划 - 01背包问题 1.使用递归遍历(穷举)求解: 01背包问题:给定 n 种物品和一个重量(容量)(限定条件)为 w 的背包,物品 i 的重量是 wi,其价值为 vi.(每种物品只有一个)问 ...
动态规划-----------01背包，完全背包与多重背包
P01: 01背包问题题目有N件物品和一个容量为V的背包.第i件物品的费用是c[i],价值是w[i].求解将哪些物品装入背包可使价值总和最大. 基本思路这是最基础的背包问题,特点是:每种物品仅有 ...
python动态规划01背包_01背包问题（动态规划）python实现
在01背包问题中,在选择是否要把一个物品加到背包中.必须把该物品加进去的子问题的解与不取该物品的子问题的解进行比較,这样的方式形成的问题导致了很多重叠子问题,使用动态规划来解决.n=5是物品的数量,c ...
c语言动态规划0-1背包,c++实现0-1背包问题完整源码（动态规划实现）
#include #define MAX_NUM 5 #define MAX_WEIGHT 10 using namespace std; //动态规划求解 int zero_one_pack(int ...
动态规划01背包问题求解(附c/cpp代码)
动态规划之01背包问题 1. 问题描述 2. 输入格式 3. 输出格式 4. 输入样例 5. 输出样例 6. 问题分析 7. 代码实现 8. 执行结果 1. 问题描述有 n 种物品和一个容量是 y ...
开心的小明 (NYOJ49) [动态规划.01背包]
开心的小明时间限制:1000 ms | 内存限制:65535 KB 难度:4 描述小明今天很开心,家里购置的新房就要领钥匙了,新房里有一间他自己专用的很宽敞的房间.更让他高兴的是,妈妈昨天对他 ...

动态规划——01背包

动态规划——01背包

1. 经典“01背包”

2. “01背包”方法归纳

3. 实战

3.1 分割等和子集

3.2 最后一块石头的重量 II

3.3 目标和

3.4 一和零

3.5 盈利计划

参考

动态规划——01背包相关推荐

最新文章

热门文章