【LeetCode热题100道笔记】组合总数

最新推荐文章于 2025-12-15 23:25:39 发布

原创最新推荐文章于 2025-12-15 23:25:39 发布 · 868 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #笔记 #算法

Leetcode热题100道笔记专栏收录该内容

101 篇文章

订阅专栏

题目描述

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的同一个数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：
输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：
输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：
输入: candidates = [2], target = 1
输出: []

提示：

1 <= candidates.length <= 30
2 <= candidates[i] <= 40
candidates 的所有元素互不相同
1 <= target <= 40

思考一：递归回溯（无限选→有限选转化）

核心思路是将“元素可无限选”转化为“按target限制的有限选”：

对每个元素，通过 Math.floor(target / candidates[i]) 计算其最大可选次数（选多了会超target，无需考虑），把无限选问题转为“选1~k次”的有限问题；
按数组索引顺序递归（从start开始），避免重复组合（如[2,3]和[3,2]）；
用sum实时记录当前组合和，超target则剪枝，等于target则记录结果，实现高效回溯。

算法过程

初始化：结果列表result，当前组合t，当前和sum；
递归入口：从索引0调用dfs(0)，开始处理第一个元素；
递归逻辑（处理索引start及之后元素）：
- 剪枝/终止：sum>target直接返回；sum===target，将t副本加入result返回；
- 遍历元素：从start遍历数组，计算当前元素最大可选次数k；
- 枚举选次：对每个元素，枚举选1~k次的情况：
  - 累加sum、将元素重复j次加入t，递归处理下一个元素（i+1）；
  - 回溯：减去sum、从t中删除j个该元素，恢复状态；
返回结果：递归结束后，result包含所有合法组合，返回即可。

时空复杂度

时间复杂度：O(target²·n)（n为候选数个数）
每个元素最大选次约为target/candidates[i]（最坏O(target)），递归深度约为n，每个组合生成需O(target)时间（复制数组），总复杂度近似O(target²·n)。
空间复杂度：O(target)
递归栈深度最大为target（如全选1，需target个元素），t的最大长度也为target，额外空间为O(target)。

代码

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function(candidates, target) {
    const result = [];
    const n = candidates.length;
    let t = [];
    let sum = 0;

    const dfs = function(start) {
        if (sum > target) return;
        if (sum === target) {
            result.push([...t]);
            return;
        }

        for (let i = start; i < n; i++) {
            const k = Math.floor(target / candidates[i]);
            for (let j = 1; j <= k; j++) {
                sum += candidates[i] * j;
                t.push(...Array(j).fill(candidates[i]));
                dfs(i+1);
                sum -= candidates[i] * j;
                for (let l = 1; l <= j; l++) {
                    t.pop();
                }
            }
        }

    };

    dfs(0);

    return result;   
};

思考二：递归回溯（可重复选+排序剪枝）

核心思路是通过“递归索引不递增”实现元素可重复选，结合排序剪枝减少无效分支：

可重复选的关键：递归调用时传入当前元素索引 i（而非 i+1），允许下一轮仍选择当前元素，同时限制从 start 开始遍历，避免生成顺序不同的重复组合（如 [2,3] 和 [3,2]）；
排序剪枝：对 candidates 排序后，若当前元素与 sum 之和超过 target，后续元素更大，可直接跳出循环，减少无效递归；
实时维护 sum 和 t（当前组合），sum 等于 target 时记录结果，回溯时恢复状态。

算法过程

初始化与排序：
- 初始化结果列表 result、当前组合 t、当前和 sum；
- 对 candidates 升序排序，为剪枝做准备。
递归入口：
调用 dfs(0)，从数组第0个元素开始处理（start=0 确保组合无顺序重复）。
DFS核心逻辑（处理索引 start 及之后的元素）：
- 终止条件：若 sum === target，将 t 的副本加入 result，返回；
- 遍历元素：从 start 遍历数组，对每个元素 num：
  ① 剪枝：若 sum + num > target，后续元素更大，直接跳出循环；
  ② 选择元素：sum 累加 num，num 加入 t；
  ③ 递归：调用 dfs(i)（传当前索引 i，允许重复选 num）；
  ④ 回溯：sum 减去 num，t 弹出 num，恢复状态。
返回结果：递归结束后，result 包含所有合法组合，返回即可。

时空复杂度分析

时间复杂度： $O(n × 2^(target/min_val))$
- n 为 candidates 长度，min_val 为 candidates 中的最小元素；
- 每个元素的最大选择次数约为 target/min_val，总递归分支数近似 $2^(target/min_val)$ （每个元素“选”或“不选”，但受 target 限制）；
- 每个组合生成时需复制 t（最长长度为 target/min_val），实际操作次数可简化为 O(n × 2^(target/min_val))，排序的 O(n log n) 可忽略。
空间复杂度： $O(target/min_val)$
- 递归栈深度最大为 target/min_val（如全选最小元素，需 target/min_val 次递归）；
- 当前组合 t 的最大长度也为 target/min_val，额外空间仅为递归栈和 t 的开销（结果存储不计入额外空间）。

代码

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function(candidates, target) {
    const result = [];
    const n = candidates.length;
    let t = [];
    let sum = 0;
    candidates.sort((a, b) => a - b);

    const dfs = function(start) {
        if (sum === target) {
            result.push([...t]);
            return;
        }

        for (let i = start; i < n; i++) {
            const num = candidates[i];
            if (sum + num > target) break;

            sum += num;
            t.push(num);
            dfs(i);
            sum -= num;
            t.pop();
        }

    };

    dfs(0);

    return result;   
};