494.目标和
给定一个非负整数数组，a1, a2, ..., an和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。
返回可以使最终数组和为目标数S的所有添加符号的方法数。
解析
S等于这个非负整数数组中的n个元素的正负值之和，可以将这组数分为两个部分，一部分是正数（前面添加+号的元素）P，一部分是负数（前面添加-号的元素）N，所以就有以下的推导：
S = sum(P) - sum(N)
S + sum(N) + sum(P) = sum(P) - sum(N) + sum(N) + sum(P)
S + sum(nums) = 2 * sum(P)
此时问题就可以转换为，从原数组中寻找一个子集，使得这个子集的和为(S + sum(nums))/2 ，如果能找到这样的子集，就说明存在数组和为目标数S的解。
方法一：
设定一个状态转移数组dp，dp[i][j]表示从前i个元素中寻找和为j的元素组合数量。
i = 0..n-1
j = 0..target (target = (S + sum(nums))/2)
状态转移递推式：
对于dp[i][j]其值应该等于num[i]参与组合和为j的运算方法数和不参与组合和为j的运算方法数之和。
当nums[i]参与组合和为j的运算，那么此时的从前i个元素中寻找和为j的元素组合数量就等于从前i-1个数中寻找和为j-nums[i-1]的元素组合数量；
当nums[i]不参与组合和为j的运算，那么此时的从前i个元素中寻找和为j的元素组合数量就等于从前i-1个数中寻找和为j的元素组合数量。
dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i-1]];
代码实现：
public static int findTargetSumWays(int[] nums, int S) {
if (nums == null || (nums.length == 1 && nums[0] != Math.abs(S)) ){
return 0;
}
int sum = sumArray(nums);
if (sum < S || (sum + S) % 2 != 0){
return 0;
}
int target = (sum + S) / 2;
int n = nums.length;
int[][] dp = new int[n+1][target+1];
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= target; j++) {
if (j >= nums[i-1]){
dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i-1]];
}else {
dp[i][j] = dp[i-1][j];
}
}
}
return dp[n][target];
}
private static int sumArray(int[] nums){
int res = 0;
for (int num : nums) {
res += num;
}
return res;
}
方法二：空间优化
dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法
有哪些来源可以推出dp[j]呢？
在j > num[i]的前提下
如果不考虑nums[i]，填满容量为j - nums[i]的背包，有dp[j - nums[i]]中方法。
那么只要搞到nums[i]的话，凑成dp[j]就有dp[j - nums[i]] 种方法，最终需要将这些方法数累加起来:dp[j] += dp[j - nums[i]]
public static int findTargetSumWays2(int[] nums, int S) {
if (nums == null || (nums.length == 1 && nums[0] != Math.abs(S)) ){
return 0;
}
int sum = sumArray(nums);
if (sum < S || (sum + S) % 2 != 0){
return 0;
}
int target = (sum + S) / 2;
int n = nums.length;
int[] dp = new int[target+1];
dp[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = target; j >= nums[i]; j--) {
dp[j] = dp[j] + dp[j - nums[i]];
}
}
return dp[target];
}
474.一和零
给你一个二进制字符串数组strs和两个整数m和n 。
请你找出并返回strs的最大子集的大小，该子集中最多有m个0和n个1 。
如果x的所有元素也是y的元素，集合x是集合y的 子集 。
方法一：
dp[i][j][k] 表示在字符串数组中的前i个元素中，不超过m个0和n个1的最大子集的大小。
public static int findMaxForm(String[] strs, int m, int n) {
int[][] zeroOnes = zeroOneNums(strs);
int a = strs.length;
int[][][] dp = new int[a+1][m+1][n+1];
for (int i = 1; i <= a; i++) {
for (int j = 0; j <= m; j++) {
for (int k = 0; k <= n; k++) {
if (j >= zeroOnes[i-1][0] && k >= zeroOnes[i-1][1]){
dp[i][j][k] = Math.max(dp[i-1][j][k],dp[i-1][j-zeroOnes[i-1][0]][k-zeroOnes[i-1][1]]+1);
}else {
dp[i][j][k] = dp[i-1][j][k];
}
}
}
}
return dp[a][m][n];
}
private static int[][] zeroOneNums(String[] strings){
int n = strings.length;
int[][] zeroOne = new int[n][2];
for (int i = 0; i < strings.length; i++) {
for (int j = 0; j < strings[i].length(); j++) {
if (strings[i].charAt(j) == '0'){
zeroOne[i][0] ++;
}else if (strings[i].charAt(j) == '1'){
zeroOne[i][1] ++;
}
}
}
return zeroOne;
}
方法二：空间优化
public static int findMaxForm2(String[] strs, int m, int n) {
int[][] zeroOnes = zeroOneNums(strs);
int[][] dp = new int[m+1][n+1];
for (int i = 0; i < strs.length; i++) {
for (int j = m; j >= zeroOnes[i][0]; j--) {
for (int k = n; k >= zeroOnes[i][1]; k--) {
dp[j][k] = Math.max(dp[j][k],dp[j-zeroOnes[i][0]][k-zeroOnes[i][1]]+1);
}
}
}
return dp[m][n];
}