[leetcode] 416. Partition Equal Subset Sum - 分割等和子集

Description

Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.

Note:

1. Each of the array element will not exceed 100.
2. The array size will not exceed 200.

Example 1:

Input:

[1, 5, 11, 5]

Output:

true

Explanation:

The array can be partitioned as [1, 5, 5] and [11].

Example 2:

Input:

 [1, 2, 3, 5]

Output:

false

Explanation:

The array cannot be partitioned into equal sum subsets.

分析

题目的意思是：给定一个数组，求这个数组能不能分成两个非空子集合，使得两个子集合的元素之和相同。

• 原数组所有数字和一定是偶数，不然根本无法拆成两个和相同的子集合，那么我们只需要算出原数组的数字之和，然后除以2，就是我们的target.
• 那么问题就转换为能不能找到一个非空子集合，使得其数字之和为target。
• 遍历所有子集合，算和，但是这种方法无法通过OJ的大数据集合。于是就可以用动态规划；dp[i]表示数字i是否是原数组的任意个子集合之和，那么最后只需要返回dp[target]就行了。
• 初始化dp[0]为true，由于题目中限制了所有数字为正数，就不用担心会出现和为0或者负数的情况。
• 关键问题就是要找出状态转移方程，首先遍历原数组中的数字，对于遍历到的每个数字nums[i]，我们需要更新dp数组，要更新[nums[i], target]之间的值，那么对于这个区间中的任意一个数字j，如果dp[j - nums[i]]为true的话，那么dp[j]就一定为true，于是状态转移方程如下：
  dp[j] = dp[j] || dp[j - nums[i]] (nums[i] <= j <= target)

C++ 代码

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum=accumulate(nums.begin(),nums.end(),0);
        if(sum&1){
            return false;
        }
        sum=sum/2;
        vector<bool> dp(sum+1,false);
        dp[0]=true;
        for(int x:nums){
            for(int i=sum;i>=x;i--){
                dp[i]=dp[i]||dp[i-x];
            }
        }
        return dp[sum]; 
    }
};

Python 解法一

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        sum_val=0
        nums.sort()
        for i in range(len(nums)):
            sum_val+=nums[i]
        if(sum_val%2==1):
            return False
        target=sum_val//2
        dp=[False]*(target+1)
        dp[0]=True
        for num in nums:
            for i in range(target,num-1,-1):
                dp[i]=dp[i] or dp[i-num]
        return dp[target]

Python 解法二

dp[i][j]表示从数组的[0,i]下标范围内选取若干个正整数（可以是0个），是否存在一种选取方案使得选取的正整数和为j，初始化的dp全为False。

边界条件：

• 如果不选取任何正整数，则被选取的正整数之和为0。因此对于0<=j<n，都有dp[i][0]=true
• 当i==0的时候，只有一个正整数nums[0]可以被选取，因此dp[0][nums[0]]=true

对于i>0 和j>0的情况：有选和不选两种情况，如下图所示

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        target = sum(nums)
        max_val = max(nums)
        if target %2 ==1:
            return False
        target = target//2
        if max_val>target:
            return False
        dp=[[False]*(target+1) for i in range(len(nums))]
        dp[0][0]=True
        dp[0][nums[0]]=True
        for i in range(len(nums)):
            for j in range(target+1):
                if j==0:
                    dp[i][j]=True
                elif j<nums[i]:
                    dp[i][j]=dp[i-1][j]
                else:
                    dp[i][j]=dp[i-1][j] or dp[i-1][j-nums[i]]
        return dp[-1][target]

下面的解法不需要特别注意初始值dp[0][nums[0]]的设计，我还是比较推荐的：

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        target = sum(nums)
        max_val = max(nums)
        if target%2==1:
            return False
        target = target//2
        if max_val>target:
            return False
        n = len(nums)
        dp = [[False]*(target+1) for _ in range(n+1)]
        
        for i in range(n+1):
            dp[i][0]=True
        for i in range(1,n+1):
            for j in range(target+1):
                if j<nums[i-1]:
                    dp[i][j]=dp[i-1][j]
                else:
                    dp[i][j]=dp[i-1][j]|dp[i-1][j-nums[i-1]]
        return dp[n][target]

Python 解法三

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        # 要求找到元素和为sum/2的子集
        if sum(nums)%2>0:
            return False
        target = sum(nums)//2
        # 初始化dp数组
        dp =[[0 for _ in range(target+1)] for _ in range(len(nums))]
		# 第0个物品初始化
        for j in range(nums[0],target+1):
            dp[0][j]=nums[0]
		# 剩下的物品根据递推公式进行推导
        for i in range(len(nums)):
            for j in range(target+1):
                if j<nums[i]:
                    dp[i][j]=dp[i-1][j]
                else:
                    dp[i][j]=max(dp[i-1][j],dp[i-1][j-nums[i]]+nums[i])
        # 判断dp的最后一个元素是否等于targe可以推导能否划分成两个相等的子集
        return dp[-1][-1]==target

参考文献

[编程题]palindrome-partitioning
[LeetCode] Partition Equal Subset Sum 相同子集和分割