416. 分割等和子集

416. 分割等和子集

原始题目链接：https://leetcode.cn/problems/partition-equal-subset-sum/

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

示例 1：

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

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

解题思路：

直观的解法是使用递归，一层层的查找，递归的优化是使用记忆化的方式存储中间结果。第二种方法是使用动态规划的方法，定义状态 dp[i][j]:从前i个元素中选出若干个数字的和为j

代码实现：

方法1

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        from functools import cache
        # 定义一个带缓存的（记忆功能）递归函数
        @cache
        def dfs(index, cur_sum):
            # index是num数组中元素的索引
            # cur_sum记录已选择的数字之和
            # 递归结束条件
            # 找到了符合的条件
            if cur_sum == target:
                return True
            # 遍历所有的nums都没有找到符合的条件
            if index == len(nums):
                return False
            # 不选择当前元素
            ans1 = dfs(index + 1, cur_sum)
            # 选择当前元素加入到cur_sum
            ans2 = dfs(index + 1, cur_sum + nums[index])

            return ans1 or ans2

        total = sum(nums)
        # 如果total不能一分为二，则表示不能分割两个子集，使得他们的和相等
        if total % 2 != 0:
            return False
        
        # 子集的和
        target = total // 2

        # 如果数组nums中的最大元素都比子集的和大，那一定不可分割
        if max(nums) > target:
            return False
        
        return dfs(0, 0)

方法2

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        total = sum(nums)
        if total % 2 != 0:
            return False
        target = total // 2

        if max(nums) > target:
            return False

        n = len(nums)

        # 定义dp[i][j]:从前i个元素中选出若干个数字的和为j
        # 初始化
        dp = [[False] * (target + 1) for _ in range(n + 1)]
        dp[0][0] = True

        for i in range(1, n + 1):
            for j in range(target + 1):
                # 当前要组成的和j小于当前元素的值num[i - 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]

参考文献：
https://leetcode.cn/problems/partition-equal-subset-sum/solution/by-flix-szk7/