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

前段时间帮朋友模拟面试,出了这道「组合总和 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 分别在不同的层被选中,这是不同位置的元素,必须保留。

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

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

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

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

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

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

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

java 复制代码
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 且和前一个相等,会被误杀,直接漏解。
java 复制代码
// ❌ 错误写法: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 工程化加分写法(可选项,面试提一嘴就加分)

如果时间充裕,可以把代码再打磨一下,这些细节很能体现工程素养:

java 复制代码
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[],否则照样会漏会重。等价写法:

java 复制代码
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;

这个判断的语义值得细品:

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

相关推荐
wno7041 小时前
Centos下PostgreSQL安装部署详细步骤
java·数据库·spring boot
wo_jack1 小时前
C++ 入门笔记(十八):list 进阶 —— const 迭代器、operator-> 与 clear 的坑
数据结构·c++·面试·stl·list
一起学安全技术1 小时前
拆大模型 11|大模型面试拷问:12 问逐层拆
人工智能·ai·语言模型·面试·职场和发展·求职招聘
nice_lcj5202 小时前
【从零理解计算机网络 · 04】TCP 三次握手:为什么恰好是三次
java·后端·tcp/ip·计算机网络·面试·tcp·三次握手
Sarvartha2 小时前
反射综合案例:SQL 语句生成
java·开发语言
思想觉悟2 小时前
Android启动流程之点rc文件
android·linux·面试
Resean022312 小时前
Spring 源码分析(二)配置类的解析与扫描
java·后端·spring
小毛球.12 小时前
第 3 篇:IDEA 最新版下载与完整安装教程(Mac)
java·macos·intellij-idea·idea
ShineWinsu13 小时前
对于Qt:QFormLayout常见属性以及方法的解析
开发语言·c++·qt·面试·客户端·表单·qformlayout