1049.最后一块石头的重量II
有一堆石头，每块石头的重量都是正整数。
每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。
示例：
- 输入：[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]，这就是最优值。
提示：
- 1 <= stones.length <= 30
- 1 <= stones[i] <= 1000
本题要求最小的石头重量，最好的情况就是最后剩下的两个石头重量一致，结果为0。那也就跟昨天的分割子集的本质一样，将这个数组分割成两个子集，使得两个子集的元素和相等。因此看是否可以将石头重量集合拆分为总和为sum/2的子集。因为本题石头粉碎是不可逆的，因此属于01背包问题，那么就开始对应如下四点：
- 背包的可容纳的重量为sum / 2
- 背包要放入的石头的重量也就是石头的价值
- 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
- 背包中每一个元素是不可重复放入
动规五部曲：
- 确定dp数组以及下标的含义：dp[j]表示重量为j的背包，最多可以背的重量为dp[j]
- 确定递推公式：dp[j]=max(dp[j], dp[j-stones[i]]+stones[i])
- dp数组如何初始化：sum+=stones[i] target=sum/2
- 递归顺序：先遍历石头，再遍历重量，并且重量要倒序遍历
如果背包需要满足的容量为target，当dp[target]==target时，背包就装满了，也就是本题的结果为0。如果不能满足，因为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=0;i<stones.length;i++){
sum+=stones[i];
}
int target=sum>>1;
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 (sum-dp[target])-dp[target];
}
}注意：这里不需要再单独判断一下dp[target]是否等于target了，如果等于的话，其实最后相当于sum-2*target=0了，如果多写了这一步判断，反而会漏算情况。
并且sum/2的空间复杂度要比sum>>1，移位运算高，所以最好写后者。
494.目标和
给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。
返回可以使最终数组和为目标数 S 的所有添加符号的方法数。
示例：
- 输入：nums: [1, 1, 1, 1, 1], S: 3
- 输出：5
解释：
- -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
一共有5种方法让最终目标和为3。
提示：
- 数组非空，且长度不会超过 20 。
- 初始的数组的和不会超过 1000 。
- 保证返回的最终结果能被 32 位整数存下。
这道题先用动态规划五部曲想了一下：本题依然是只能取一次，所以还是01背包思路
- 确定dp数组以及下标的含义：dp[j]表示达到和为j的值有dp[j]种方法
- 确定递推公式：目前还不知道
- dp数组如何初始化：dp[0]=1，因为当只有1个元素的时候，那么就只有一种方法
- 确定遍历顺序：还是按照元素从前向后，按照数值从后向前
- 举例推导dp数组：递推公式还没出来，暂时举不出来例子
脑子比较累，直接看了题解：
本题要如何使表达式结果为target。首先因为有sum，所以left + right = sum，sum是固定的，因此right = sum - left。既然为target，那么就一定有 left组合 - right组合 = target，这里left就是加法的总和，right就是减法的总和，公式来了， left - (sum - left) = target 推导出 left = (target + sum)/2, target是固定的，sum是固定的，left就可以求出来。此时问题就是在集合nums中找出和为left的组合。此时问题就转化为，装满容量为left的背包，有几种方法。还要注意几种特殊的情况：(target + sum) / 2 应该担心计算的过程中向下取整有没有影响，如果sum为5，target为2，那么无论怎样也不会到达target值，也就是说当sum+target为奇数时，是没有解决方案的。并且如果target的的绝对值大于sum，也是没有解决方法的，直接返回0。
只要搞到nums[i]，凑成dp[j]就有dp[j - nums[i]] 种方法。
例如：dp[j]，j 为5，
- 已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 容量为5的背包。
- 已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 容量为5的背包。
- 已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 容量为5的背包
- 已经有一个4（nums[i]） 的话，有 dp[1]中方法 凑成 容量为5的背包
- 已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 容量为5的背包
那么凑整dp[5]有多少方法呢，也就是把 所有的 dp[j - nums[i]] 累加起来。
所以求组合类问题的公式，都是类似这种：dp[j] += dp[j - nums[i]]
import java.lang.Math;
class Solution {
public int findTargetSumWays(int[] nums, int target) {
int sum=0;
for(int i=0;i<nums.length;i++){
sum+=nums[i];
}
int left=(sum+target)>>1;
if((sum+target)%2==1) return 0;
if(Math.abs(target)>sum) return 0;
int[] dp= new int[left+1];
dp[0]=1;
for(int i=0;i<nums.length;i++){
for(int j=left;j>=nums[i];j--){
dp[j]+= dp[j-nums[i]];
}
}
return dp[left];
}
}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
本题还是一个背包问题，本题中strs 数组里的元素就是物品，每个物品都是一个，只能取一次，因此还是01背包问题。这里限制了两个元素的大小，这两个大小之间是没有什么制约关系的，相当于有两个背包，所以要定义一个二维dp数组dp[i][j]继续开始动规五部曲：
- 确定dp数组以及下标的含义：dp[i][j]表示最多取i个1和j个0后的最大子集的大小
- 确定递推公式：dp[i][j]是由前一个已经选好的子串推导而来，假设前面那个子串已经有zero个0和one个1，那么dp[i][j]=dp[i-zero][j-one]+1，并且还要跟自己做比较，取最大值。
- dp数组如何初始化：初始化为0
- 确定遍历顺序：遍历物品要从前往后，遍历背包要从后往前，这里m和n都是背包，所以都是从后往前遍历。
- 举例推导dp数组：以输入：["10","0001","111001","1","0"]，m = 3，n = 3为例，最后dp数组的状态如下所示：
class Solution {
public int findMaxForm(String[] strs, int m, int n) {
int[][] dp = new int[m+1][n+1];
for(String str:strs){
int zero=0, one=0;
for(char c : str.toCharArray()){
if(c =='0') zero++;
else one++;
}
for(int i=m;i>=zero;i--){
for(int j=n;j>=one;j--){
dp[i][j]=Math.max(dp[i][j], dp[i-zero][j-one]+1);
}
}
}
return dp[m][n];
}
}
