2021-09-23 分割等和子集

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

来自 https://leetcode-cn.com/problems/partition-equal-subset-sum/

分析题目

该题目的意思是，能否将给定的数组分成两个数组，使得两个数组的元素和相等
另一种表述就是，该数组是否存在一个子数组，使得子数组的元素和等于总元素和的一半
类似于0-1背包问题，0-1背包问题的条件是，要求选取的物品的重量之和不超过背包的总容量
而该题的条件是，要求选取的数字之和恰好等于元素总和的一半

动态规划

dp[i][j]表示，在下标为0-i的数组中，是否存在子数组，使得元素和等于 j
数组的总长度为n，数组的所有元素和为sum，target=sum/2
则当前题目的解是dp[n-1][target]

对于当前数

1. 若nums[i]>j，则不能选nums[i]，则dp[i][j]=dp[i-1][j]
2. 若nums[i]<=j，则可以选或不选
    不选：dp[i][j]=dp[i-1][j] 或 选：dp[i-1][ j-nums[i] ] 只要有一个是true，dp[i][j]就是true

状态转移方程：

dp[i][j] = dp[i−1][j] ∣ dp[i−1][j−nums[i]] , j≥nums[i]
dp[i][j] = dp[i−1][j] , j<nums[i]

​

边界处理：

1. 当i==0时，只能取nums[0]，则dp[0][nums[0]]等于true
2. 当j==0时，只要不选取，dp就为true，所以dp[i][0]等于true

特殊情况处理

1. 当数组长度小于2时，不能满足题目要求，直接返回false
2. 计算数组的所有元素之和
    当数组的所有元素之和为奇数时，不能满足题目要求，因此直接返回false
    当最大的数大于数组所有元素和的一半时，也不能满足要求

代码

class Solution {
    public boolean canPartition(int[] nums) 
    {
        int n=nums.length;
        //元素个数的特殊处理
        if(n<2)
        {
            return false;
        }
        //求出最大值和总和
        int sum=0;
        int most=0;
        for(int i=0;i<n;i++)
        {
            most=Math.max(most,nums[i]);
            sum+=nums[i];
        }
        //总和的特殊处理
        if(sum%2!=0)
        {
            return false;
        }
        if(sum/2<most)
        {
            return false;
        }
        int target=sum/2;
        boolean[][] dp=new boolean[n][target+1];
        //边界处理
        //当i=0
        /*for(int j=0;j<=target;i++) //可以省略，默认值为false
        {
            dp[0][j]=false;
        }*/
        dp[0][nums[0]]=true;
        //当j等于0
        for(int i=0;i<n;i++)
        {
            dp[i][0]=true;
        }
        //开始动规
        for(int i=1;i<n;i++)
        {
            for(int j=1;j<=target;j++)
            {
                dp[i][j]=dp[i-1][j];
                if(nums[i]<=j)
                {
                    if(dp[i-1][j-nums[i]]==true)
                    {
                        dp[i][j]=true;
                    }
                }
            }
        }
        return dp[n-1][target];
    }
}

优化

1. 上述空间复杂度为O（n*target），观察得出，每一行的dp值，只与上一行的dp值有关
因此只需要维护一个dp[j]数组即可，将空间复杂度降低到O（target）
2. 在j的循环中
 for (int j = target; j >= num; --j) 
  {
    dp[j] |= dp[j - num];
 }

代码：

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