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