做题笔记 -- 动态规划（分割等和子集）

代码参考
为了个人学习方便，同时贴上c++和python的代码

题目描述

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

示例1：

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

示例2：

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

分析

关键：找到集合里能够出现sum / 2的子集总和
可以用回溯法或者动态规划法

回溯

cpp代码

class Solution {
// 总和为sum，判断是否存在和为sum/2的组合
// 回溯方法
// 没有理解
vector<unordered_map<int, bool>> memo;

private:
    bool dfs(vector<int>& nums, int i, int target) {
        // 扫描到头依然没有找到合适的，返回false
        if(i >= nums.size()) {
            return false;
        }
        auto it = memo[i].find(target);
        if(it != memo[i].end()) {
            // 有记录直接取值
            return it->second;
        }
        bool ret;

        // ----------考虑当前数----------
        if(target < nums[i]) {
            ret = false;
        } else if(target == nums[i]) {
            // 已找到，直接剪枝
            ret = true;
        } else {
            ret = dfs(nums, i + 1, target - nums[i]);
        }

        // ----------再把不考虑当前数的结果或上----------
        ret = ret || dfs(nums, i + 1, target);

        memo[i][target] = ret;
        return ret;
         
    }
public:
    bool canPartition(vector<int>& nums) {
        int sum = std::accumulate(nums.begin(), nums.end(), 0);
        if(sum % 2) {
            // sum为奇数
            return false;
        }
        
        memo = vector<unordered_map<int, bool>>(nums.size());
        return dfs(nums, 0, sum / 2);

    }
};

python代码

class Solution:
    def __init__(self):
        self.memo = []
    
    def dfs(self, nums, i, target):
        if i >= len(nums):
            return False

        if target in self.memo[i]:
            return self.memo[i][target]

        ret = False

        # Consider the current number
        if target < nums[i]:
            ret = False
        elif target == nums[i]:
            ret = True
        else:
            ret = self.dfs(nums, i + 1, target - nums[i])

        # Consider without the current number
        ret = ret or self.dfs(nums, i + 1, target)

        self.memo[i][target] = ret
        return ret
        
    def canPartition(self, nums: List[int]) -> bool:
        total_sum = sum(nums)
        if total_sum % 2 != 0:
            return False
        
        target = total_sum // 2
        self.memo = [{} for _ in range(len(nums))]
        return self.dfs(nums, 0, target)

动态规划

cpp代码

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = std::accumulate(nums.begin(), nums.end(), 0);
        if(sum % 2) {
            return false;
        }
        int target = sum / 2;
        // 本题的weight和value都是nums
        // dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
        vector<int> dp(target + 1, 0);  // 注意dp数组的范围
        // 遍历：顺序不能反(一维数组)
        for(int i = 0; i < nums.size(); i++) {          // 遍历物品
            for(int j = target; j >= nums[i]; j--) {    // 遍历背包(倒序遍历)
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        if(dp[target] == target) return true;
        return false;


    }
};

python代码

# 一维度数组解法
class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        target = sum(nums)
        if target % 2 == 1: return False
        target //= 2
        dp = [0] * (len(nums) + 1)
        for i in range(len(nums)):
            for j in range(target, nums[i] - 1, -1):
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
        return target == dp[target]

问题

1. 没有理解回溯的代码怎么想的。
2. 不能一眼看出来这题要用动态规划