动态规划经典——分割等和子集(子集背包问题)

题目

416. 分割等和子集

难度中等778

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

 

示例 1：

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

示例 2：

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

 

 

分析

1.该题是将数组拆分成两个不同元素的子集，转换为背包问题，即求sum/2的背包容量，能不能刚刚好(不多不少)放下元素。

2.理解到这个，该题就和之前的文章完全背包问题类似——换硬币问题(https://blog.csdn.net/mk33092250/article/details/116259528)

3.构建dp数组， boolean[][] dp = new boolean[nums.length + 1][max + 1];

4.初始化值dp[i][0]=true

5.状态转移方程

• 当前元素不放，dp[i][j] = dp[i - 1][j];
• 当前元素放入的话，那么dp[i][j] =  dp[i - 1][j - nums[i - 1]];

代码实现

public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        //奇数，没有结果
        if (sum % 2 != 0) {
            return false;
        }
        return canPartition(nums,sum/2);

    }

    public boolean canPartition(int[] nums, int max) {
        //构建dp数组
        boolean[][] dp = new boolean[nums.length + 1][max + 1];
        for (int i = 0; i <= nums.length; i++) {
            dp[i][0] = true;
        }
        for (int i = 1; i <= nums.length; i++) {
            for (int j = 1; j <= max; j++) {
                //小于背包，才可以放
                if (nums[i - 1] <= j) {
                    dp[i][j] = dp[i - 1][j] | dp[i - 1][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }

        }
        return dp[nums.length][max];
    }

进阶

查看题解后，发现还有更好的实现方法，记录下思路

其实dp数组只用一维就行了

• dp方程boolean[] dp = new boolean[max + 1];
• 初始化值dp[0]=true；
• 状态转移方程dp[j] = dp[j] || dp[j - nums[i]];(不放入元素||放入元素)

 

代码

public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        //奇数，没有结果
        if (sum % 2 != 0) {
            return false;
        }
//        return canPartition(nums,sum/2);
        return canPartition2(nums, sum / 2);


    }


    public boolean canPartition2(int[] nums, int max) {
        //构建dp数组
        boolean[] dp = new boolean[max + 1];
        dp[0] = true;
        for (int i = 0; i < nums.length; i++) {
            for (int j = max; j >= 0; j--) {
                //小于背包，才可以放
                if (nums[i] <= j) {
                    dp[j] = dp[j] || dp[j - nums[i]];

                }
            }
        }
        return dp[max];
    }

注意

这里的第二个for循环为什么要反向遍历？

注意我们的状态转移方程，又分为放入和不放入两种状态，反向遍历流程如下：

假设入参元素为[1，2，2，5]

第一次遍历，当i=0，此时计算放入index=0的元素1后，dp的值为true，true，false，false，false，false；

第二次遍历，当i=1，此时计算放入index=1的元素2后，dp的值为true，true，true，true，false，false；

....

这样状态转移方程易于转换(也重复利用了dp数组)。

 

如果使用正向遍历，我们需要存储已经放过的元素的位置，代码如下(可进一步优化，这里不做过多优化处理)：

public boolean canPartition3(int[] nums, int max) {
        //构建dp数组
        boolean[] dp = new boolean[max + 1];
        dp[0] = true;
        for (int i = 0; i < nums.length; i++) {
            //记录被使用过的位置
            boolean[] temp = new boolean[max + 1];
            for (int j = 0; j <= max; j++) {
                //不放元素，此位置可以用其他元素填充
                if (dp[j]){
                    continue;
                }
                //需要放入元素，小于背包，才可以放，且没有放过
                if (nums[i] <= j && !temp[j - nums[i]]) {
                    if (dp[j - nums[i]]) {
                        //记录哪个位置存放过元素
                        temp[j]=true;
                        dp[j] = dp[j - nums[i]];
                    }
                }
            }
        }
        return dp[max];
    }