【两次过】【背包】Lintcode 588. 划分和相等的子集

给一 只含有正整数 的 非空 数组, 找到这个数组是否可以划分为 两个 元素和相等的子集。

样例

例1:

输入: nums = [1, 5, 11, 5], 
输出: true
解释:
two subsets: [1, 5, 5], [11]

例2:

输入: nums = [1, 2, 3, 9], 
输出: false

注意事项

所有数组元素不超过100.
数组大小不超过200.

---

解题思路：

典型的背包问题，是Lintcode 92. 背包问题的变种。在n个物品中挑选出一定的物品，看是否能填满容量sum/2的背包

dp[i][j]表示在前i个物品中挑选物品是否能将容量为j的背包填满

初始条件：看第一个物品能否填满容量依次为0...sum/2的背包

递推式：

两种情况：

（1）不装入当前物品，直接为上一个物品的结果：dp[i][j] = dp[i-1][j]

（2）若能装入当前物品，则装入当前物品与不装当前物品的两种情况的取并集，只要有一种为true即为true：dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]]

public class Solution {
    /**
     * @param nums: a non-empty array only positive integers
     * @return: true if can partition or false
     */
    public boolean canPartition(int[] nums) {
        // write your code here
        int sum = 0;
        for(int i=0; i<nums.length; i++)
            sum += nums[i];
        
        if(sum % 2 == 1)
            return false;
        
        //dp[i][j]表示在前i个物品中挑选物品是否能将容量为j的背包填满
        boolean[][] dp = new boolean[nums.length][(sum/2) + 1];
        
        //初始条件，第一行
        for(int i=0; i<=sum/2; i++)
            dp[0][i] = (i == nums[0]) ? true : false;
        
        //递推式
        for(int i=1; i<nums.length; i++){
            for(int j=0; j<=sum/2; j++){
                if(j < nums[i])
                    dp[i][j] = dp[i-1][j];
                else
                    dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]];
            }
        }
        
        return dp[nums.length-1][sum/2];
    }
}

一维数组版本：

public class Solution {
    /**
     * @param nums: a non-empty array only positive integers
     * @return: true if can partition or false
     */
    public boolean canPartition(int[] nums) {
        // write your code here
        int sum = 0;
        for(int i=0; i<nums.length; i++)
            sum += nums[i];
        
        if(sum % 2 == 1)
            return false;
        
        boolean[] dp = new boolean[(sum/2) + 1];
        
        //初始条件，第一行
        for(int i=0; i<=sum/2; i++)
            dp[i] = (i == nums[0]) ? true : false;
        
        //递推式
        for(int i=1; i<nums.length; i++){
            for(int j=sum/2; j>=nums[i]; j--){
                dp[j] = dp[j] || dp[j-nums[i]];
            }
        }
        
        return dp[sum/2];
    }
}

三刷：

public class Solution {
    /**
     * @param nums: a non-empty array only positive integers
     * @return: true if can partition or false
     */
    public boolean canPartition(int[] nums) {
        // write your code here
        if(nums.length < 2)
            return false;
        int sum = 0;
        for(int i : nums)
            sum += i;
        
        if(sum % 2 != 0)
            return false;
        
        int[] dp = new int[(sum/2)+1];
        for(int i=0; i<dp.length; i++)
            dp[i] = nums[0] <= i ? nums[0] : 0;
        
        for(int i=1; i<nums.length; i++)
            for(int j=sum/2; j>=nums[i]; j--)
                dp[j] = Math.max(dp[j], nums[i]+dp[j-nums[i]]);
        
        if(dp[sum/2] == sum/2)
            return true;
        return false;
    }
}