前段时间帮朋友模拟面试,出了这道「组合总和 II」。他回溯框架写得飞快,结果一跑测试——[1,2] 输出了两遍。这道题号称回溯专题的"门面题",考的根本不是你能不能写出回溯,而是你能不能把去重和剪枝讲明白。据我观察,80% 的候选人都卡在去重逻辑上,能一遍写对、还能讲清 why 的,基本直接进入下一轮。
这篇文章把这道题从题意、思路、代码到面试追问彻底拆透,适合正在刷回溯专题、或者准备大厂面试的同学。全文代码 Java,可直接提交。
一、先看清题:三个约束叠在一起,才是坑
题目地址: leetcode.cn/problems/co…
题目本身一句话:从 candidates 里选若干个数凑成 target,每个数字在一个组合里只能用一次,结果集里不能有重复组合。
约束范围:1 <= candidates.length <= 100,1 <= candidates[i] <= 50,1 <= target <= 30。
单独看每个条件都不难,难的是三个条件叠加:
| 关键约束 | 具体含义 | 对解法的直接影响 |
|---|---|---|
| 数组有重复元素 | candidates 里可能有相同数字 | 必须做去重 |
| 每个元素只能用一次 | 不可无限复用 | 递归时传 i + 1,而不是 i |
| 结果不能有重复组合 | 来自不同下标的 [1,2,5] 算同一个 | 需要同层去重剪枝 |
它和 LC 39「组合总和 I」是亲兄弟,但差别恰好都在坑上:
| 维度 | LC 39 组合总和 | LC 40 组合总和 II |
|---|---|---|
| 候选元素 | 无重复 | 可能重复 |
| 使用次数 | 无限次 | 仅一次 |
| 递归传参 | i(可重复选自己) | i + 1(选完就往后走) |
| 去重 | 不需要 | 排序 + 同层去重 |
| 越界剪枝 | break | break |
面试开口第一句可以这么说:"这道题本质上是回溯,但由于数组有重复元素且每个元素只能用一次,去重是核心难点。一句话概括:40 = 39 + 去重 + 限用一次。"
二、重复到底是怎么产生的?
很多同学知道要去重,但说不清楚为什么不去重就会错。拿 candidates = [1, 1, 2]、target = 3 举例,直接套 39 题的模板(把"可重复"改成"不可重复"),搜索树会长成这样:
明明两个 1 是不同下标,但值相同,导致 [1, 2] 被生成了两次。这就是所谓的树层重复。
这里有个关键理解:把回溯看成一棵 N 叉树,横向(for 循环)是"同一层的选择",纵向(递归)是"往深处走"。值相同的元素出现在同一层时,选谁往下走,展开的子树一模一样,所以同一层只保留第一个就够了。
反过来,纵向上的重复是合法的——比如 [1,1,6] 凑 8,两个 1 分别在不同的层被选中,这是不同位置的元素,必须保留。
💡 一句话记住去重逻辑:同一层不能选相同的值,不同层可以选相同的值。横不可重,纵可重。
三、解题框架:排序铺路,回溯三板斧
整体还是回溯的标准套路:选 → 递归 → 撤销。但要解决两个问题:
- 每个数只能用一次 → 递归下一层从
i + 1开始,不能从i开始; - 结果不能重复 → 先排序让相同数字挨在一起,再在同一层上跳过重复数字。
排序是这道题的地基,去重和剪枝都建立在它之上:
为什么必须排序?两个原因:
- 去重的前提:相同数字必须挨在一起,才能用
nums[i] == nums[i-1]一眼认出。原始数组[1, 2, 1, 3]里两个 1 相隔很远,判断直接失效;排序后[1, 1, 2, 3],O(1) 就能判断重复。 - 剪枝的前提:升序后一旦
nums[i] > remain,后面只会更大,可以break整层退出;不排序只能continue干瞪眼,白白多搜。
四、递归树走一遍,看清两把剪刀落在哪里
以 candidates = [1,1,2,5,6,7,10]、target = 8(已排序)为例:
看图说话:
- 同一层上,第二个
1如果敢再当一次分支头,就会和第一个1分叉出一模一样的子树(比如[1,7]和[1',7]),产生重复组合。所以要在「层」上去重,而不是在「枝」上去重。 - 选了 5 之后剩 3,下一个候选是 6,
6 > 3,由于数组有序,后面的 7、10 更大,break直接砍掉整条尾巴。 - 口诀:
continue砍的是「横向的重复分支」,break砍的是「纵向的无底洞」。
看到这里,如果你对这类面试题拆解感兴趣,可以顺手点个关注,后面我会把回溯专题的高频题挨个拆一遍。
五、核心代码(可直接 AC)
class Solution {
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(candidates); // ① 排序:去重和剪枝的共同前提
backtrack(candidates, target, 0, new ArrayList<>(), res);
return res;
}
private void backtrack(int[] nums, int remain, int start,
List<Integer> path, List<List<Integer>> res) {
if (remain == 0) { // ② 凑齐了,收割
res.add(new ArrayList<>(path)); // ⚠️ 必须拷贝,不能存引用
return;
}
for (int i = start; i < nums.length; i++) {
// ③ 剪枝:数组已升序,当前数都比剩余和大了,后面更大,直接 break
if (nums[i] > remain) break;
// ④ 同层去重(全题灵魂):i > start 表示"不是本层第一个"
if (i > start && nums[i] == nums[i - 1]) continue;
path.add(nums[i]); // 做选择
// ⑤ 每个元素只能用一次 → 下一层从 i + 1 开始
backtrack(nums, remain - nums[i], i + 1, path, res);
path.remove(path.size() - 1); // 撤销选择,恢复现场
}
}
}
技术亮点逐行拆解
| 标记 | 代码 | 为什么重要 |
|---|---|---|
| ① | Arrays.sort(candidates) | O(n log n) 的代价换来指数级的剪枝收益,没有排序,去重和剪枝都无从谈起 |
| ② | new ArrayList<>(path) | Java 是引用传递,直接 add(path) 会因引用共享导致结果集里全是被清空的同一个列表——这是回溯题的头号坑 |
| ③ | nums[i] > remain 用 break 而非 continue | 利用有序性提前终止整层搜索,从 O(2ⁿ) 里砍一大半;写 continue 就是"剪了个寂寞" |
| ④ | i > start && nums[i]==nums[i-1] | 本题灵魂。i > start 是区分"同层重复"和"同枝合法重复"的关键,差一个字符结果天差地别 |
| ⑤ | 下一层传 i + 1 | 保证每个数在一个组合里只被用一次;写成 i 就变成 39 题了 |
六、几个最容易翻车的细节,展开说说
6.1 为什么是 i > start,写成 i > 0 会怎样?
这是本题最容易翻车的点,没有之一。
i > start:表示「同一层(同一轮 for 循环)里,不是第一个元素」才去重,start才是"本层起点"。- 若写成
i > 0:会把同一条递归树枝上的相同数字也剪掉。比如[1,1,6]凑7这种合法组合,第二个1在往下递归时索引大于 0 且和前一个相等,会被误杀,直接漏解。
// ❌ 错误写法:i > 0,纵向合法重复被一并剪掉
if (i > 0 && nums[i] == nums[i - 1]) continue;
// ✅ 正确写法:i > start,只剪横向同层重复
if (i > start && nums[i] == nums[i - 1]) continue;
💡 记忆口诀:同层去重用
i > start,树枝保留靠放行i == start的第一个。
6.2 continue 和 break 别用混
| 情况 | 该用 | 原因 |
|---|---|---|
| 同层遇到重复数字 | continue | 只跳过这个,后面不同值的可能还能用 |
| 当前数已超过剩余和 | break | 数组有序,后面全更大,整层没必要再看 |
用错的表现很隐蔽:剪枝写成 continue 不会报错,只是超时;去重写成 break 则会漏解。面试时主动讲清这两者的区别,是"你有没有想清楚"的分水岭。
6.3 工程化加分写法(可选项,面试提一嘴就加分)
如果时间充裕,可以把代码再打磨一下,这些细节很能体现工程素养:
class Solution {
private final List<List<Integer>> res = new ArrayList<>();
private final Deque<Integer> path = new ArrayDeque<>(); // 双端队列做路径
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
dfs(candidates, target, 0, 0);
return res;
}
private void dfs(int[] c, int target, int sum, int start) {
if (sum == target) {
res.add(new ArrayList<>(path));
return;
}
for (int i = start; i < c.length; i++) {
if (c[i] > target - sum) break; // 等价 sum+c[i] > target,但防 int 溢出
if (i > start && c[i] == c[i - 1]) continue;
path.addLast(c[i]);
dfs(c, target, sum + c[i], i + 1); // 和作为参数下传
path.removeLast(); // 尾删 O(1)
}
}
}
| 亮点 | 为什么值得写 |
|---|---|
c[i] > target - sum 替代 sum + c[i] > target | 数学等价,但不会 int 溢出,工程素养加分 |
sum 作为参数下传 | 比每层 path.stream().sum() 省掉 O(n),整体从 O(2ⁿ·n) 降为 O(2ⁿ) 量级 |
ArrayDeque 替代 ArrayList 做 path | 官方推荐替代 Stack,addLast/removeLast 都是 O(1),语义也更清晰 |
复用同一个 path 对象 | 回溯过程零额外内存分配,无废物对象 |
七、面试官追问:不用排序,用 used[] 行不行?
行,但要先排序再用 used[],否则照样会漏会重。等价写法:
boolean[] used = new boolean[c.length];
// ...
if (i > 0 && c[i] == c[i - 1] && !used[i - 1]) continue; // 前一个同值数在本层未被使用 → 同层重复,跳过
used[i] = true;
dfs(c, target, sum + c[i], i + 1, used);
used[i] = false;
这个判断的语义值得细品:
used[i-1] == false ⟺ 前一个相同数在本层被"跳过/未选" ⟺ 当前是同层重复分支,剪
used[i-1] == true ⟺ 前一个相同数在本路径上已被选 ⟺ 合法的深层延续,如 [1,1,...],放行
两种写法本质一样——只允许相同数字的第一次出现在本层被选中:
| 方案 | 空间 | 适用场景 |
|---|---|---|
i > start | O(1),无额外数组 | 组合/子集类,有 start 天然分层,代码最简洁,本题首选 |
used[] | O(n) | 更通用,LC 47 全排列 II 必须用它(排列没有 start 概念,每层从 0 扫描) |
🗣️ 面试话术:"两种写法我都会。本题用
i > start更优雅,因为start天然把层分开了,少维护一个数组;used[]更通用,全排列 II 那种每层从头扫的题必须靠它。"
八、复杂度分析(面试官点头必备)
| 维度 | 复杂度 | 说明 |
|---|---|---|
| 排序 | O(n log n) | 一次性开销,相对指数级回溯可忽略 |
| 时间 | O(2ⁿ) 最坏 | 每个元素"选/不选"两种状态;算上输出拷贝总计 O(n · 2ⁿ),但实际因剪枝 + 去重远小于此 |
| 空间 | O(n) | 递归栈深度 + path 长度,不计结果集 |
⚡ 面试时说出"理论 O(n · 2ⁿ),实际远小于"就够了。虽然理论是指数级,但排序剪枝让真实运行远快于上界——这也是面试官想听到的工程优化意识。
九、面试追问大全(提前准备,被问就是送分)
Q1:如果不用 i > start 而用 i > 0,会怎样?
会在树枝方向也去重,像
[1,1,6]这种合法组合被漏掉。纵向递归时第二个1的索引 > 0 且和前一个相等,被错误跳过。
Q2:这题能用动态规划吗?
严格来说可以,但非常别扭。题目要求输出所有具体组合,而 DP 更擅长"求方案数"或"求最优解"。用 DP 记录所有路径,空间开销大、代码比回溯复杂得多。回溯天然适合枚举所有合法路径,面试首选回溯。
Q3:如果只要求组合数(不输出具体组合)呢?
那就是标准 01 背包问题:
dp[j]表示凑成j的方案数,转移方程dp[j] += dp[j - candidates[i]],时间复杂度 O(n × target),比回溯快很多。
Q4:如果 candidates 里有 0 怎么办?
0 不会改变剩余 target,会导致无限递归,而且组合里加 0 也不合法。题目约束了
candidates[i] >= 1,但面试官这么问是在考察边界敏感度——答案是过滤掉所有 0 和负数。
Q5:能不能不排序做去重?
可以。思路一:每层用一个局部
HashSet记录本层已用过的值,但空间开销更大,而且失去越界break剪枝能力;思路二:按"计数桶"回溯,每个数统计出现次数后枚举选 0~k 次。排序写法代码最短、最好讲,仍是面试最优解。
Q6:n = 100 时搜索空间爆炸怎么办?
排序后
break剪枝是主力;还可以再加一道"后缀和剪枝":预处理后缀和,如果当前和加上剩余所有元素都还小于 target,说明这条路怎么都凑不够,直接break。
Q7:怎么估算实际生成的组合数?
可以用
C(n, k)做上界估算,或者直接在递归里加个计数器实测。
十、一套模板通吃:组合家族横向对比
这道题的去重思想其实是通用模板,"排序 + i > start 判断"可以套到所有"数组有重复元素的组合/子集/排列"问题上:
| 题目 | 元素可重复选 | 数组有重复 | 去重写法 | 下一层起点 |
|---|---|---|---|---|
| LC 39 组合总和 | ✅ | ❌ | 无需 | i |
| LC 40 组合总和 II | ❌ | ✅ | 同层去重 | i + 1 |
| LC 216 组合总和 III | ❌ | ❌ | 无需 | i + 1 |
| LC 90 子集 II | ❌ | ✅ | 同层去重(沿途全收割) | i + 1 |
| LC 47 全排列 II | — | ✅ | used[] 去重(每层从 0 扫) | 无 start |
🎁 面试时主动把这个"去重家族"串起来讲,面试官基本会认定你对回溯的去重模型是成体系的,而不是背题——这是实打实的加分项。
十一、收尾:把这首诗背下来
面试现场如果被要求 30 秒口述思路,可以这么说:
"这题本质是子集型回溯加双重去重:先排序,让相同数字挨在一起,去重和剪枝才有抓手;每个元素只能用一次,所以递归下一层从
i+1开始;结果去重靠同层跳过——i > start且和前一个相等就continue;剪枝利用有序性,当前数超了后面更大,直接break。"
最后送一首口诀,背下来面试直接用:
组合看 start,排列看 used; 复用传自己,单次加一; 有重先排序,同层跳弟弟; 收集必拷贝,超标就 break。
再浓缩成一句话:排序是前提,回溯是骨架,剪枝是提速,同层去重是灵魂。
落地建议:光看不练假把式。建议你现在就关掉这篇文章,用 [1,1,2,5,6,7,10]、target=8 手写一遍代码,再刻意把 i > start 改成 i > 0 跑一次,亲眼看看 [1,1,6] 是怎么消失的——踩过这一遍,这个坑你就永远不会再掉进去了。同族的 LC 90、LC 47 也建议趁热打铁一起刷掉。
互动时间:你在回溯题上踩过最深的坑是哪个?是忘了深拷贝 path,还是把 break 写成了 continue?或者你被面试官追问过什么刁钻问题?欢迎在评论区聊聊,我会挑典型的坑在下一篇专门拆解。觉得有用的话,点赞、在看走一波,关注不迷路 👋