LeetCode 40 组合总和 II:面试官想听的不是回溯,而是那行去重代码

0 阅读13分钟

前段时间帮朋友模拟面试,出了这道「组合总和 II」。他回溯框架写得飞快,结果一跑测试——[1,2] 输出了两遍。这道题号称回溯专题的"门面题",考的根本不是你能不能写出回溯,而是你能不能把去重和剪枝讲明白。据我观察,80% 的候选人都卡在去重逻辑上,能一遍写对、还能讲清 why 的,基本直接进入下一轮。

这篇文章把这道题从题意、思路、代码到面试追问彻底拆透,适合正在刷回溯专题、或者准备大厂面试的同学。全文代码 Java,可直接提交。

一、先看清题:三个约束叠在一起,才是坑

image.png

题目地址: 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(选完就往后走)
去重不需要排序 + 同层去重
越界剪枝breakbreak

面试开口第一句可以这么说:"这道题本质上是回溯,但由于数组有重复元素且每个元素只能用一次,去重是核心难点。一句话概括:40 = 39 + 去重 + 限用一次。"

二、重复到底是怎么产生的?

很多同学知道要去重,但说不清楚为什么不去重就会错。拿 candidates = [1, 1, 2]、target = 3 举例,直接套 39 题的模板(把"可重复"改成"不可重复"),搜索树会长成这样:

image.png

明明两个 1 是不同下标,但值相同,导致 [1, 2] 被生成了两次。这就是所谓的树层重复。

这里有个关键理解:把回溯看成一棵 N 叉树,横向(for 循环)是"同一层的选择",纵向(递归)是"往深处走"。值相同的元素出现在同一层时,选谁往下走,展开的子树一模一样,所以同一层只保留第一个就够了。

反过来,纵向上的重复是合法的——比如 [1,1,6] 凑 8,两个 1 分别在不同的层被选中,这是不同位置的元素,必须保留。

💡 一句话记住去重逻辑:同一层不能选相同的值,不同层可以选相同的值。横不可重,纵可重。

三、解题框架:排序铺路,回溯三板斧

整体还是回溯的标准套路:选 → 递归 → 撤销。但要解决两个问题:

  1. 每个数只能用一次 → 递归下一层从 i + 1 开始,不能从 i 开始;
  2. 结果不能重复 → 先排序让相同数字挨在一起,再在同一层上跳过重复数字。

排序是这道题的地基,去重和剪枝都建立在它之上:

image.png

为什么必须排序?两个原因:

  • 去重的前提:相同数字必须挨在一起,才能用 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(已排序)为例:

image.png

看图说话:

  • 同一层上,第二个 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 > startO(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

image.png

🎁 面试时主动把这个"去重家族"串起来讲,面试官基本会认定你对回溯的去重模型是成体系的,而不是背题——这是实打实的加分项。

十一、收尾:把这首诗背下来

面试现场如果被要求 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?或者你被面试官追问过什么刁钻问题?欢迎在评论区聊聊,我会挑典型的坑在下一篇专门拆解。觉得有用的话,点赞、在看走一波,关注不迷路 👋