LeetCode 416 分割等和子集 题解

LeetCode 416 分割等和子集 题解

LeetCode链接

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
注意:
每个数组中的元素不会超过 100
数组的大小不会超过 200
示例 1:
输入: [1, 5, 11, 5]
输出: true
解释: 数组可以分割成 [1, 5, 5] 和 [11].
示例 2：
输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。
提示：
1 <= nums.length <= 200
1 <= nums[i] <= 100

参考官方题解和liweiwei题解

可以转化为0-1背包问题，然后利用动态规划寻找是否存在一些元素加起来的和为数组元素总和的一半
dp[i][j] 表示从数组的 [0,i] 下标范围内选取若干个正整数（可以是 0 个），是否存在一种选取方案使得被选取的正整数的和等于 j。初始时，dp 中的全部元素都是 false

利用二维数组写出来的动态规划：

class Solution {
    public boolean canPartition(int[] nums) {
        int length = nums.length;
        if(length < 2){
            return false;
        }
        int sum = 0, max = 0;
        for(int num: nums){
            sum += num;
            max = Math.max(num, max);
        }
        int target = sum / 2;
        if((sum & 1) == 1 || max > target){
            return false;
        }
        boolean[][] dp = new boolean[length][target + 1];
        for(int i = 0; i < length; ++i){
            //取0个数时，和自然为0
            dp[i][0] = true;
        }
        //从[0,0]取nums[0]正好等于nums[0]
        dp[0][nums[0]] = true;
        //这样第0行和第0列就确定好了，从第一行，第一列开始遍历
        for(int i = 1; i < length; ++i){
            int num = nums[i];
            for(int j = 1; j <= target; ++j){
                if(num <= j){
                    //不选nums[i]和选择nums[i]
                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - num];
                }
                else{
                    //只能不选nums[i]
                    dp[i][j] = dp[i - 1][j];
                }
                //某一列只要有一个为true，后面就都是true了；可以根据这个剪枝
                if(dp[i][target] == true){
                    return true;
                }
            }
        }
        return dp[length - 1][target];
    }
}

压缩空间，因为新的一行置由上一行决定，由上一行的同列的值和上一行的dp[j-nums[i]]决定，所以可以把辅助空间压缩到一行，dp[j] = dp[j] || dp[j-nums[i]]但是要注意需要从后往前更新，否则用到dp[j-nums[i]]时就是一个被更新过的值了【dp[j] = dp[j] || dp[j - nums[i]] 可以理解为 dp[j] （新）= dp[j] （旧） || dp[j - nums[i]] （旧），如果采用正序的话 dp[j - nums[i]]会被之前的操作更新为新值】；另外j只需要遍历[nums[i],target],因为再往前的话，(j-nums[i])<0,这个时候根据之前的转移方程，dp[i][j] = dp[i-1][j],到这里只有一行的话也就是dp[j]不用变

class Solution {
    public boolean canPartition(int[] nums) {
        int length = nums.length;
        if(length < 2){
            return false;
        }
        int sum = 0, max = 0;
        for(int num: nums){
            sum += num;
            max = Math.max(num, max);
        }
        int target = sum / 2;
        if((sum & 1) == 1 || max > target){
            return false;
        }
        //dp[i][j] 表示从数组的 [0,i]下标范围内选取若干个正整数（可以是0个），是否存在一种选取方案使得被选取的正整数的和等于 j。初始时，
        //dp 中的全部元素都是false。
        boolean[] dp = new boolean[target + 1];
        //从[0,0]取nums[0]正好等于nums[0];不取就等于0
        dp[nums[0]] = true;
        dp[0] = true;
        //这样第0行就确定好了，从第一行开始遍历
        for(int i = 1; i < length; ++i){
            int num = nums[i];
            //j需要从大到小更新，因为dp[j - num]其实是上一行的旧值，如果从小到大，dp[j - num]就已经被更新了
            for(int j = target; j >= num; --j){
                //j
                dp[j] |=dp[j - num];
                //某一列只要有一个为true，后面就都是true了；可以根据这个剪枝
                if(dp[target] == true){
                    return true;
                }
            }
        }
        return dp[target];
    }
}