这里写自定义目录标题
1049.最后一块石头的重量Ⅱ
-
题意:有一堆石头,用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。
每一回合,从中选出任意两块石头,然后将它们一起粉碎。假设石头的重量分别为 x 和 y,且 x <= y。那么粉碎的可能结果如下:
如果 x == y,那么两块石头都会被完全粉碎;
如果 x != y,那么重量为 x 的石头将会完全粉碎,而重量为 y 的石头新重量为 y-x。
最后,最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下,就返回 0。示例 1: 输入:stones = [2,7,4,1,8,1] 输出:1 解释: 组合 2 和 4,得到 2,所以数组转化为 [2,7,1,8,1], 组合 7 和 8,得到 1,所以数组转化为 [2,1,1,1], 组合 2 和 1,得到 1,所以数组转化为 [1,1,1], 组合 1 和 1,得到 0,所以数组转化为 [1],这就是最优值。 示例 2: 输入:stones = [31,26,33,21,40] 输出:5
-
思路:尽量把石头分成重量相等的两堆石头,返回这两堆石头重量的差就行
-
动规五部曲
- dp数组的含义
dp[j]:背包容量为j(总重量的一半)所背的最大重量=价值。 - 递归公式
dp[j] = Math.max(dp[j], dp[j - stone[i]] + stone[i]) - 初始化
初始化为0即可 - 遍历顺序
先遍历物品,再遍历背包。背包要倒序遍历。
- dp数组的含义
class Solution {
public int lastStoneWeightII(int[] stones) {
//计算stones的重量总和
int sum = 0;
for(int s: stones) {
sum += s;
}
int target = sum/2;
//dp数组的含义:dp[j]表示背包容量为j(总重量的一半)所背的最大重量=价值。
int[] dp = new int[target + 1];
//遍历物品,正序遍历
for(int i = 0; i < stones.length; i++) {
//遍历背包,倒序遍历
for(int j = target; j >= stones[i]; j--) {
dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
}
}
//返回两堆石头的重量差
return Math.abs((sum - dp[target]) - dp[target]);
//或者直接返回 sum - dp[target] - dp[target]即可,因为target是sum/2,是向下取整,所以dp[target]肯定小的。
}
}
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
-
思路:
- 加法的总和为x,则减法的总和为sum - x;
那么target = x - (sum - x),即 x = (sum + target) / 2
问题转化成,装满x,即装满(sum + target)/ 2容量的背包,有几种方法。也就是:装满x,等于
确定哪些数前面用+号,剩下的自然就用减号了。 - 剪枝:如果sum + target为奇数,那么除以二会向下取整,这样肯定凑不出来x,直接return 0;
- 加法的总和为x,则减法的总和为sum - x;
-
动规五部曲
-
dp[j]:含义 :容量为j的背包,有 dp[j] 种方 式:dp[j] = dp[j - nums[i]]
-
递推公式:
例如dp[j],背包容量为5 1,2,3,4,5都是nums[i]; 已经有一个1的话,则有dp[4]种方法凑成容量为4的背包,总和为dp[5] 已经有一个2的话,则有dp[3]种方法凑成容量为3的背包,总和为dp[5] 已经有一个3的话,则有dp[2]种方法凑成容量为2的背包,总和为dp[5] 已经有一个4的话,则有dp[1]种方法凑成容量为1的背包,总和为dp[5] 已经有一个5的话,则有dp[0]种方法凑成容量为0的背包,总和为dp[5]
dp[5]是由以上5种情况的总和推导出来的,
即dp[5] = dp[4] + dp[3] + dp[2] + dp[1] + dp[0]
对以上递推公式进行抽象的话:
即dp[j] += dp[j - nums[i]]; -
dp数组初始化
dp[0] 初始化为1,因为dp[0]是递推结果的起源,如果初始化为0的话,递推结果都将为0;已经有一个5的话,足有dp[0]种方法凑成容量为0的背包,此时容量总和为5,dp[0]种方法初始化为1,则有1种方法。
-
确定遍历顺序
外层循环nums,内层循环背包容量(倒序循环) -
举例推导dp数组
nums = {1,1,1,1,1}, S = 3;
bagSize = (S+sum)/2 = 8/2 =4
-
class Solution {
public int findTargetSumWays(int[] nums, int target) {
//整数和为x,负数和为sum - x;
//target = x - (sum - x), x = (target + sum) /2
int sum = 0;
for(int i = 0; i < nums.length; i++) sum += nums[i];
int bagSize = (target + sum) /2;
//剪枝
if((target + sum) % 2 == 1) return 0;
//如果target过大,sum将无法满足
if(target < 0 && sum < -target) return 0;
if(target > 0 && sum < target) return 0;
int[] dp = new int[bagSize + 1];
dp[0] = 1;
for(int i = 0; i < nums.length; i++) {
for(int j = bagSize; j >= nums[i]; j--) {
dp[j] += dp[j - nums[i]];
}
}
return dp[bagSize];
}
}
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
-
思路:
数组里的元素就是物品,每个物品为1个。
m和n相当于一个背包,是两个维度的背包。一个维度是m(装1),一个维度是n(装0) -
动规五部曲
- dp[i][j] :含义,最多有i个0和j个1的strs的最大子集的大小是dp[i][j]
- 递推公式:dp[i][j]可以由前一个strs里的字符串推导,strs里的字符串有zeroNum个0,oneNum个1。
dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1;
在遍历过程中取到dp[i][j]的最大值。
dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum]dp[j - oneNum] + 1) - 数组初始化
初始为0即可 - 遍历顺序
外层遍历物品,即strs里的字符串
外层遍历物品,也就是字符串数组里的每一个字符串,最外层的循环
内层遍历背包,也就是0和1的个数,倒序遍历。这里是两层for循环嵌套。遍历m和n
-
代码如下
class Solution {
public int findMaxForm(String[] strs, int m, int n) {
int[][] dp = new int[m+1][n+1];
int zeroNum, oneNum;
for(String s: strs) {
zeroNum = 0;
oneNum = 0;
for(char ch: s.toCharArray()) {
if(ch == '0') zeroNum++;
else oneNum++;
}
for(int i = m; i >= zeroNum; i--) {
for(int j = n; j >= oneNum; j--) {
dp[i][j] = Math.max(dp[i][j],dp[i-zeroNum][j-oneNum]+1);
}
}
}
return dp[m][n];
}
}