【LeetCode】416. 分割等和子集 结题报告 (python)

原题地址：https://leetcode-cn.com/problems/partition-equal-subset-sum/submissions/

题目描述：

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

注意:

每个数组中的元素不会超过 100
数组的大小不会超过 200
示例 1:

输入: [1, 5, 11, 5]

输出: true

解释: 数组可以分割成 [1, 5, 5] 和 [11].
 

示例 2:

输入: [1, 2, 3, 5]

输出: false

解释: 数组不能分割成两个元素和相等的子集.

 

解题方案：

动态规划，就是占用的空间太大了。。。

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        nums_sum = sum(nums)
        if nums_sum % 2 == 1:
            return False
        else:
            dp = [0] * (nums_sum + 1)
            dp[0] = 1
            half = int(nums_sum / 2)
            for num in nums:
                i = half - 1
                while i >= 0:
                    if dp[i]:
                        dp[i + num] = 1
                    i -= 1
                if dp[half]:
                    return True 
            return False

最简单的方案是用了递归的方法：

class Solution:
    def canPartition(self, nums) -> bool:
        numadd = sum(nums)
        target = numadd // 2
        if target * 2 != numadd:
            return False
        return self.addsum(nums, target)
        # sums = sum(nums)
        # if sums % 2:
        #     return False
        # sums //= 2
        # dp = [False] * (sums + 1)
        # dp[0] = True
        # for num in nums:
        #     for j in range(sums,-1,-1):
        #         if j >= num:
        #             dp[j] = dp[j] or dp[j - num]
        #         if dp[-1]:
        #             return True
        # return dp[-1]

    def addsum(self, nums, target):
        if target < 0 or len(nums) < 1:
            return False
        if target == 0:
            return True
        if len(nums) == 1:
            return nums[0] == target
        if self.addsum(nums[1:], target - nums[0]):
            return True
        j = 1
        while j < len(nums) and nums[j] == nums[0]:
            j += 1
        if self.addsum(nums[j:], target):
            return True
        return False

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        """
            只包含正整数
            分成元素和想等 那么每个集合都是 sum(nums) // 2 （在sum(nums)为偶数 ，奇数没答案
            问题变成哪几个元素和等于 sum(nums) // 2 
            
            DFS + 记忆化 + 逆排序数组 超时
            
        """
        total = sum(nums)
        if total & 1:
            return False
        n = len(nums)
        nums = sorted(nums, reverse=True)

        def dfs(i, target):
            if target == 0:
                return True
            if i < n and target < nums[i]:
                return False
            for j in range(i, n):
                if dfs(j + 1, target - nums[i]):
                    return True
            
            return False
            
        
        return dfs(0, total // 2)