1049. 最后一块石头的重量 II
有一堆石头,用整数数组 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
问题分析:
1、确定dp数组以及下标的含义
dp[j]:是容量(容量更形象,其实是重量)为j的背包,最多可以背最大重量为dp[j]
石头的重量是 stones[i],石头的价值也是 stones[i] ,可以 “最多可以装的价值为 dp[j]” == “最多可以背的重量为dp[j]”
2、确定递推公式
01背包的递推公式为:dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
本题则是:dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
3、dp数组初始化
依旧是dp[j]都初始化为0,防止覆盖所求dp[j]
4、确定遍历顺序
01滚动数组,物品遍历的for循环放在外层,遍历背包的for循环放在内层,且内层for循环倒序遍历
5、举例推导dp数组
本题的思路是要求target为最大重量的一半,dp[target]里是容量为target的背包所能背的最大重量。
那么分成两堆石头,一堆石头的总重量是dp[target],另一堆就是sum - dp[target]。
在计算target的时候,target = sum / 2 因为是向下取整,所以sum - dp[target] 一定是大于等于dp[target]的。
那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。
class Solution {
public int lastStoneWeightII(int[] stones) {
int sum=0;
for(int i: stones){
sum=sum+i;
}
int target=sum/2;
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]);
// System.out.print(dp[j]+"\t");
}
// System.out.print("\n");
}
return (sum-dp[target])-dp[target];//12-11
}
}
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
问题分析:
把数组分为两个数组,正数和负数数组。
left为正数数组的和,right为负数数组的和
- left+right=sum
- left-right=target
整理方程组,得出:right=(sum-target)/2
因为数组nums元素中都是非负整数,所以right也为非负整数,所以式子成立的前提是:
sum-target为非负偶数,若不符合则返回0。
若上式成立,问题转化成在数组 nums 中选取若干元素,使得这些元素之和等于 right,计算选取元素的方案数。我们可以使用动态规划的方法求解。
1、确定dp数组以及下标的含义
dp[i][j]:在nums[i]中,前i个数加起来组成的和为j,有dp[i][j]种方法。
2、确定递推公式
- 如果 j<nums[i-1](为什么不直接nums[i],是因为循环内i从1开始,漏下了nums[0],所以要i-1),则不能选nums[i-1],此时有:dp[i][j] = dp[i - 1][j]
- 如果 j≥nums[i-1],则如果不选nums[i-1],方案数是dp[i][j] = dp[i-1][j],如果选 nums[i-1],方案数是dp[i-1][j-nums[i-1]],此时有 dp[i][j] = dp[i-1][j]+dp[i-1][j-nums[i-1]]
3、dp数组初始化
当没有元素可以取时,元素和只能为0,对应的方法有1种:dp[0][0]=1
4、确定遍历顺序
i 和 j 遍历顺序前后都可以
5、举例推导dp数组
class Solution {
public int findTargetSumWays(int[] nums, int target) {
int sum=0;
for (int i:nums){
sum=sum+i;
}
if ((sum-target)<0||(sum-target)%2!=0) return 0;//等式不成立
int right=(sum-target)/2;
int[][] dp=new int[nums.length+1][right+1];
dp[0][0]=1;//初始值设为1,0组成0有一种方法
for(int i=1;i<=nums.length;i++){
for (int j=0;j<=right;j++){
dp[i][j]=dp[i-1][j];//记录上方元素
if (j>=nums[i-1]){//如果此时的负数集合的和>
dp[i][j]=dp[i][j]+dp[i-1][j-nums[i-1]];//上方元素+左上方元素
}
}
}
/*for (int i = 0; i<=nums.length; i++) {
for (int j = 0; j <= right; j++) {
System.out.print(dp[i][j] + "\t");
}
System.out.println("\n");
}*/
return dp[nums.length][right];
}
}
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 。
问题分析:
本题中strs 数组里的元素就是物品,而m 和 n相当于是一个背包,两个维度的背包。相当于二维滚动数组。
1、确定dp数组以及下标的含义
dp[i][j]:最多有 i 个0和 j 个1的strs的最大子集大小为dp[i][j]。
dp[i][j] 就可以是 dp[i - zero][j - one] + 1
在遍历的过程中,取dp[i][j]的最大值。
所以递推公式:dp[i][j] = max(dp[i][j], dp[i - zero][j - one] + 1)
字符串的zero和one相当于物品的重量(weight[i]),字符串strs的个数(子集个数)相当于物品的价值(value[i])。
2、确定递推公式
dp[i][j] 可以由前一个strs里的字符串二维滚动数组推导出来,
3、dp数组初始化
dp[0][0]=0,防止覆盖
4、确定遍历顺序
滚动数组,从后向前遍历
5、举例推导dp数组
class Solution {
public int findMaxForm(String[] strs, int m, int n) {
int dp[][]=new int[m+1][n+1];
dp[0][0]=0;
int zero,one;
for (String str:strs){
zero=0;
one=0;
for (char ch:str.toCharArray()){//toCharArray()转化字符数组
if (ch=='0'){
zero++;
}
else {
one++;
}
}
for (int i=m;i>=zero;i--){//容量要大于目前已有的0个数
for (int j=n;j>=one;j--){容量要大于目前已有的1个数
dp[i][j]=Math.max(dp[i][j],dp[i-zero][j-one]+1);//dp[i-zero][j-one]+1去掉此时的情况再加此时的这个子集数,也就是+1
}
}
/* for (int i = 0; i<=m; i++) {
for (int j = 0; j <= n; j++) {
System.out.print(dp[i][j] + "\t");
}
System.out.println("\n");
}*/
}
return dp[m][n];
}
}