代码参考
为了个人学习方便,同时贴上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]
问题
- 没有理解回溯的代码怎么想的。
- 不能一眼看出来这题要用动态规划