416.分割等和子集
给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
注意:
每个数组中的元素不会超过 100
数组的大小不会超过 200
示例 1:
输入: [1, 5, 11, 5]
输出: true
解释: 数组可以分割成 [1, 5, 5] 和 [11].
方法一
对于此题，如果能够分割成两个子集，同时这两个子集的元素和相等，那么前提是这个数组的所有元素的和是一个偶数，否则一定不能分割成两个元素和相等的子集；
如果所有的元素和是一个偶数，那么符合要求，我们接下来的目标就是寻找一个子集，这个子集的元素和应该是数组所有元素和的一半，就只要能够找到一个子集合它的所有元素和是 sum / 2，那么返回true，暂且把sum/2命名为target；
这是一个典型的0-1背包问题，target相等于背包的容量。采用动态规划的解决方案如下：
1.定义一个状态转移数组dp,dp[i][j]表示前i个元素中能否找到和为j的元素的子集，dp数组的类型是布尔类型
2.寻找状态转移方程：对于第i个元素，如果其放入“背包”中，那么dp[i][j]值应该是dp[i][j] = dp[i-1][j-nums[i]]；如果不放入“背包”中，那么dp[i][j] = dp[i-1][j];
3.确定初始值，dp[0][0] = true，因为对于前0个元素，其和就是0，所以是能够找到和为0的子集合的。
public boolean canPartition(int[] nums) {
if (nums == null || nums.length == 0){
return true;
}
int sum = 0;
for (int num : nums) {
sum += num;
}
if (sum % 2 != 0){
return false;
}
int target = sum / 2;
int n = nums.length;
boolean[][] dp = new boolean[n+1][target+1];
dp[0][0] = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; 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];
}
方法二
针对上面的思路和方法，将状态数组进行空间压缩，使用一维数组记录状态。
public boolean canPartition2(int[] nums) {
if (nums == null || nums.length == 0){
return true;
}
int sum = 0;
for (int num : nums) {
sum += num;
}
if (sum % 2 != 0){
return false;
}
int target = sum / 2;
int n = nums.length;
boolean[] dp = new boolean[target+1];
dp[0] = true;
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];
}
方法三
不使用布尔类型的dp数组，使用int类型的数组，物品的价值可以看作是nums[i]，物品的体积也可以看作是nums[i]，这样我们的问题就是在求寻找一组数，使得这组数在不超过target的前提下，价值尽可能的接近target，而由于物品的价值和体积的值都是一样的，所以对于占数组中所有元素值之和一半的容量值target，其能装入的物品的最大的价值也就是target，而对于能够分为两个等和子集的数组来说，其最终一定是dp[target]==target。
public boolean canPartition2(int[] nums){
if (nums == null){
return false;
}
int sum = getSumArray(nums);
if (sum % 2 != 0){
return false;
}
int target = sum / 2;
int[] dp = new int[target+1];
dp[0] = 0;
for (int i = 0; i < nums.length; i++) {
for (int j = target; j >= nums[i]; j--) {
dp[j] = Math.max(dp[j],dp[j - nums[i]]+nums[i]);
}
}
return dp[target]==target;
}
1049.最后一块石头的重量||
有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 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]，这就是最优值。
解析
本题可以转换为将这一组石头分为两堆，使得这两堆的石头的总重量尽量相同，这样碰撞之后剩下的石头的重量就是最小的。定义一个状态数组dp，dp[j]表示可称重为j的背包所装的最大重量。
其中对于一块石头来说，stone[i]即表示物品的重量，又表示物品的价值。首先我们计算出用于分堆的容量，即为这组石头总重量的一半：
target = sum / 2
我们期望往这个容量为target的背包中尽可能装入重的石头，这样就能使得两堆石头的总重量接近了。
状态转移表达式即为：
dp[j] = Math.max(dp[j],dp[j-stones[i]] + stones[i]);
初始化：
对于dp[0]，因为容量为0，所以装入的重量也为0；对于其他元素的初始值，由于我们要求的是每个容量的最大值，所以初始值都设置为0
dp[0] = 0
代码实现
public int lastStoneWeightII(int[] stones) {
int sum = getSumArray(stones);
if (sum == 0){
return 0;
}
int target = sum / 2;
int[] dp = new int[target+1];
dp[0] = 0;
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];
}
private int getSumArray(int[] nums){
int res = 0;
for (int num : nums) {
res+=num;
}
return res;
}