LeetCode 力扣热题100 分割等和子集
题目解析
题目：给定一个正整数数组 nums，判断是否可以将数组分成两个和相等的子集。
等价问题：
• 计算 nums 的总和 S
• 如果 S 是奇数，直接返回 false（因为不能均分）
• 目标是找到一个子集，使得子集和等于 S / 2
• 这相当于 0-1 背包问题：是否能从 nums 中选取一些数，使其和为 S / 2
解法：动态规划
1. 状态定义
使用 一维 DP 数组 dp[j]：
• dp[j] = true 表示存在一个子集，使得该子集的和为 j
• dp[j] = false 表示不存在这样的子集
目标：判断 dp[target] 是否为 true，其中 target = S / 2
2. 递推公式
• 遍历数组 nums，对于当前元素 num
• 倒序遍历 j = target 到 num，更新 dp[j]
• dp[j] = dp[j] || dp[j - num]
• 如果 dp[j - num] 为 true，说明 j - num 可达，那么 j 也可达
• 如果 dp[j] 原本为 true，则仍为 true
3. 初始化
• dp[0] = true（空集的和为 0）
代码分析
class Solution {
public:
bool canPartition(vector<int>& nums) {
int s = accumulate(nums.begin(), nums.end(), 0); // 计算总和
if (s % 2 != 0) return false; // 总和为奇数，无法均分
int target = s / 2; // 目标和
vector<bool> dp(target + 1, false); // DP 数组，表示是否能组成某个和
dp[0] = true; // 0 直接可达
for (int num : nums) { // 遍历每个数
for (int j = target; j >= num; j--) { // 逆序遍历
dp[j] = dp[j] || dp[j - num];
}
}
return dp[target]; // 看 target 是否可达
}
};详细运行步骤
示例 1
输入：
nums = {1, 5, 11, 5}计算总和：
• S = 1 + 5 + 11 + 5 = 22
• target = 22 / 2 = 11
• 需要找到一个子集和为 11
DP 过程：
初始化：
dp = [true, false, false, false, false, false, false, false, false, false, false, false]（下标 0 代表和为 0 可达）
遍历 1：
dp[1] = dp[1] || dp[1 - 1] (true)dp = [true, true, false, false, false, false, false, false, false, false, false, false]
遍历 5：
dp[6] = dp[6] || dp[6 - 5] (true)
dp[5] = dp[5] || dp[5 - 5] (true)dp = [true, true, false, false, false, true, true, false, false, false, false, false]
遍历 11：
dp[11] = dp[11] || dp[11 - 11] (true)dp = [true, true, false, false, false, true, true, false, false, false, false, true]
最终 dp[11] = true，返回 true
案例分析
我们用一个不同的测试案例，详细跟踪 dp 数组的变化。
示例 2
输入
nums = {3, 3, 3, 4, 5}计算总和：
• S = 3 + 3 + 3 + 4 + 5 = 18
• target = 18 / 2 = 9
• 目标是找到一个子集，使得该子集的和为 9
初始化
我们初始化 dp 数组：
dp = [true, false, false, false, false, false, false, false, false, false]• dp[0] = true，表示和为 0 的子集是可行的（空集）
遍历每个数
遍历 3（第一个）
更新 dp[j]，从 target = 9 逆序到 num = 3
dp[3] = dp[3] || dp[3 - 3] = truedp 变化：
dp = [true, false, false, true, false, false, false, false, false, false]表示可以用 {3} 得到和 3
遍历 3（第二个）
dp[6] = dp[6] || dp[6 - 3] = true
dp[3] = dp[3] || dp[3 - 3] = true （已经是 true）dp 变化：
dp = [true, false, false, true, false, false, true, false, false, false]表示可以用 {3, 3} 得到和 6
遍历 3（第三个）
dp[9] = dp[9] || dp[9 - 3] = true
dp[6] = dp[6] || dp[6 - 3] = true （已经是 true）
dp[3] = dp[3] || dp[3 - 3] = true （已经是 true）dp 变化：
dp = [true, false, false, true, false, false, true, false, false, true]表示可以用 {3, 3, 3} 得到和 9 ✅ 目标达成
遍历 4
dp[9] = dp[9] || dp[9 - 4] = true （已经是 true）
dp[7] = dp[7] || dp[7 - 4] = true
dp[4] = dp[4] || dp[4 - 4] = truedp 变化：
dp = [true, false, false, true, true, false, true, true, false, true]表示可以用 {4} 得到和 4，可以用 {3, 4} 得到 7
遍历 5
dp[9] = dp[9] || dp[9 - 5] = true
dp[8] = dp[8] || dp[8 - 5] = true
dp[5] = dp[5] || dp[5 - 5] = truedp 变化：
dp = [true, false, false, true, true, true, true, true, true, true]可以用 {5} 得到 5，用 {3, 5} 得到 8
最终结果
✅ dp[9] = true，说明可以找到一个子集使得总和为 9，返回 true
完整执行过程
| dp 状态 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
|---|---|---|---|---|---|---|---|---|---|---|
| 初始 | T | F | F | F | F | F | F | F | F | F |
| 处理 3 | T | F | F | T | F | F | F | F | F | F |
| 处理 3 | T | F | F | T | F | F | T | F | F | F |
| 处理 3 | T | F | F | T | F | F | T | F | F | T |
| 处理 4 | T | F | F | T | T | F | T | T | F | T |
| 处理 5 | T | F | F | T | T | T | T | T | T | T |
dp[9] = true，所以可以划分两个子集和相等。
复杂度分析
• 时间复杂度：O(n × target) 其中 target = S/2
• 空间复杂度：O(target) 只用了一维 dp
总结
✅ 思路：
1. 计算 S，如果 S 为奇数直接返回 false
2. 定义 dp[j]：表示能否找到一个子集，使得总和为 j
3. 遍历 nums，使用 逆序 更新 dp，确保不会重复使用数字
4. 最终 dp[target] 是否为 true，决定是否能划分
✅ 关键优化点：
• 使用 一维 DP 数组（空间优化）
• 倒序遍历 j，避免同一轮重复使用 nums[i]
✅ 时间复杂度：
• O(n × sum/2)，适用于 sum 适中的情况（sum < 10^5）
✅ 空间复杂度：
• O(sum/2)，降低空间占用