day36|1049. 最后一块石头的重量 II、494. 目标和、474.一和零
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[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
- 如果 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];
}
}