416.分割等和子集

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

提示：

• 1 <= nums.length <= 200
• 1 <= nums[i] <= 100

思路

首先我们先判断如果数组长度小于2，则一定无法将数组分割为两个子集，然后统计数组中元素总和，若总和sum为奇数，则也无法分割为两个子集，因为所有元素均为正整数。然后再来思考整个问题：我们想要把整个数组分为两个子集，并且两个子集的元素和相等，那么我们只要确定整个数组中存在元素和等于sum/2的子集即可，我们可以从数组下标[0,i]开始，判断该段元素能否组成和为[1,sum/2]的子集即可，可以使用动态规划法。

记数组长度为n，sum/2为target，定义一个dp数组dp[n][target+1]，初始化为false，dp[i][j]表示数组下标从0到i能否组成总和为j的子集。

首先初始化dp数组，如果j==0，那么不选择元素即可，所以我们记为true，如果i为0，此时只有nums[0]可以选择，所以我们记dp[0][nums[0]]=true.

接着是递推公式，我们对dp数组按行进行遍历，如果j>=nums[i]，那么需要考虑元素i选择或者不选择的情况，那么dp[i][j]等于dp[i-1][j]与dp[i-1][j-nums[i]]做或运算的结果，前者表示不选择元素i，后者表示选择元素i。如果j<nums[i]，那么一定不会选择元素i，因为放入就会导致总和大于目标值j，所以dp[i][j]=dp[i-1][j].

还有一个要注意的点是，如果数组中有元素大于target，即大于总和的一般，那么一定不能分割为两个等和子集，因为数组只包含正整数。

代码

class Solution {
        public boolean canPartition(int[] nums) {
            int n=nums.length;
            if(n<2){
                return false;
            }
            int sum=0,max=0;
            for(int i:nums){
                sum+=i;
                max=Math.max(max,i);
            }
            if(sum%2==1){
                return false;
            }
            int target=sum/2;
            if(max>target){
                return false;
            }
            boolean[][] dp=new boolean[n][target+1];
            for(int i=0;i<n;i++){
                dp[i][0]=true;
            }
            dp[0][nums[0]]=true;
            for(int i=1;i<n;i++){
                int num=nums[i];
                for(int j=1;j<target+1;j++){
                    if(j>=nums[i]){
                        dp[i][j]=dp[i-1][j]|dp[i-1][j-num];
                    }else {
                        dp[i][j]=dp[i-1][j];
                    }
                }
            }

            return dp[n-1][target];
        }
    }

1049.最后一块石头的重量Ⅱ

有一堆石头，用整数数组 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 <= stones.length <= 30
• 1 <= stones[i] <= 100

思路

用归纳法证明，无论按照任何顺序粉碎石头，最后一块石头的重量总是可以表示成：

记石头的总重量为sum，ki=-1的石头的重量之和为neg，其余的为sum-leg，则

要使最后一块石头尽可能小，则要使neg不超过sum/2的情况下尽可能大，因此本问题可以看作背包容量为sum/2，物品重量和价值均为stonesi的01背包问题。

dp数组和递推公式与上题一样，不同之处是仅需初始化dp[0][0]为真。

在递推结束后，找到所有为真的dp[n][j]中，最大的j即为neg能取到的最大值，带入sum-2*neg即可得到最后一块石头的最小重量。

代码

class Solution {
        public int lastStoneWeightII(int[] stones) {
            int n=stones.length;

            int sum=0;
            for(int i:stones){
                sum+=i;
            }
            int target=sum/2;
            boolean[][] dp=new boolean[n+1][target+1];
            dp[0][0]=true;
            for(int i=0;i<n;i++){
                for(int j=0;j<target+1;j++){
                    if(j>=stones[i]){
                        dp[i+1][j]=dp[i][j]|dp[i][j-stones[i]];
                    }else {
                        dp[i+1][j]=dp[i][j];
                    }
                }
            }
            for(int j=target;;j--){
                if(dp[n][j]){
                    return sum-2*j;
                }
            }
        }
    }