leetcode：组合与组合总和（JavaScript）

77. 组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

• 1 <= n <= 20
• 1 <= k <= n

思路：

常规解法，因为每个数字在一个组合中只能使用一次，所以我们需要在递归中传入一个开始位置，告诉每一层前面哪些数字已经使用过了，本层递归单层逻辑中for循环从哪里开始。

var combine = function(n, k) {
    let res = [];
    let path = [];
    let dfs = function (start, k) {
        // 递归结束条件
        if (path.length === k) {
            res.push([...path]);
            return;
        }
        for (let i = start; i <= n; i++) {
            path.push(i);
            dfs(i + 1, k);
            path.pop();
        }
    }
    dfs(1, k);
    return res;
};

优化剪枝

在处理递归单层逻辑for循环时可以优化，当本层的开始位置到start到n的范围内的数字无法构成一个长度为k的组合时就没必要继续循环下去了，直接退出本层循环。

1. 已经选择的元素个数：path.size();
2. 还需要的元素个数为: k - path.size();
3. 在集合n中至多要从该起始位置 : n - (k - path.size()) + 1，开始遍历（加1的目的是构成一个左闭的集合）

 for (let i = start; i <= n -k + path.length + 1; i++) 

var combine = function(n, k) {
    let res = [];
    let path = [];
    let dfs = function (start, k) {
        if (path.length === k) {
            res.push(Array.from(path));
            return;
        }
        for (let i = start; i <= n -k + path.length + 1; i++) {
            path.push(i);
            dfs(i + 1, k);
            path.pop();
        }
    }
    dfs(1, k);
    return res;
};

39. 组合总和

给你一个 无重复元素 的整数数组 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
• 1 <= candidates[i] <= 200
• candidate 中的每个元素都 互不相同
• 1 <= target <= 500

思路

因为一个元素可以重复取多次，所以递归传入的开始标记就是当前元素下标，不能每次for循环都从0开始，因为那样会造成重复的组合，如题中例1就会取出[2,2,3],[2,3,2]，若sum === target那么记录当前组合。

剪枝优化

首先对candidates数组性小到大排序，那么若当前元素的和值大与目标值，那么后续的所有元素的和值都会大与目标值，所以没必要再循环下去，直接退出循环。

var combinationSum = function(candidates, target) {
    // 排序，默认排序是按字符串拍的，会出问题，一定要按这种方式
    candidates.sort((a, b) => {
        return a - b;
    });
    const res = [], path = [];
    let dfs = function (sum, start) {
        // 记录组合
        if (sum === target) {
            res.push (Array.from(path));
            return;
        }
        // 优化剪枝
        for (let i = start; i < candidates.length && sum + candidates[i] <= target; i++) {
            path.push(candidates[i]);
            dfs (sum + candidates[i], i);
            path.pop();
        }
    }
    dfs (0, 0);
    return res;
};

40. 组合总和 II

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意： 解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

提示:

• 1 <= candidates.length <= 100
• 1 <= candidates[i] <= 50
• 1 <= target <= 30

思路

在处理本题时，首先要想明白本题分为横向遍历取开始节点后的元素，递归纵向不断调整开始标记，根据题目要求每个数字在组合中只许用一次，且结果中不能包含相同的组合，candidates数组中有重复元素，所以本题的难点就是如何去重。首先要明白横向遍历不能使用重复的元素，递归可以使用，如题目中给出的例子，candidates数组中有两个 1 ，[1,1,6]是合法的，但是当使用第二个1构成组合[1,2,5]时就是不合法的，因为第一个1已经构成了该组合。

实现

首先对candidates数组性小到大排序，这样相同的元素就会在一起，用变量used记录前一个字符，若for循环中当前元素和used值相同，那么就直接跳过，去重。排序后还可以对递归进行剪枝优化，因为从小到大排序，所以若当前元素的和值大与目标值，那么后续的所有元素的和值都会大与目标值，所以没必要再循环下去，直接退出循环。

// 剪枝
for (let i = start; i < candidates.length && sum + candidates[i] <= target; i++) {
    // 去重
    if (used === candidates[i]) continue;
    else used = candidates[i];
    ...
}

完整代码

var combinationSum2 = function(candidates, target) {
    // 排序，默认排序是按字符串拍的，会出问题，一定要按这种方式
    candidates.sort((a, b) => {
        return a - b;
    });
    const res = [], path = [];
    let dfs = function (sum, start) {
        let used = 0;
        // 因为for循环中有了剪枝的限制条件，所以能进入递归的sum一定小于等于目标值
        if (sum === target) {
            res.push (Array.from(path));
            return;
        }
        for (let i = start; i < candidates.length && sum + candidates[i] <= target; i++) {
            // 去重
            if (used === candidates[i]) continue;
            // 更新used
            else used = candidates[i];
            path.push(candidates[i]);
            dfs (sum + candidates[i], i + 1);
            path.pop();
        }
    }
    dfs (0, 0);
    return res;
};

216. 组合总和 III

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

• 只使用数字1到9
• 每个数字 最多使用一次

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例 3:

输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

提示:

• 2 <= k <= 9
• 1 <= n <= 60

递归终止条件

递归终止条件是下面的条件，因为题目限制了只能取k个数，所以无论k个数的和是否等于sum，都应该结束递归

if (path.length === k)

而下面的条件只是满足上面条件后，判断是否需要记录当前path内容的条件。

if (sum === n)

剪枝优化

这里有两次剪枝

1. 因为只能使用1~9的数字，并且我们的for循环从1开始，所以下一层递归选取的数字只能比上一层的大，若当前的组合和值就大于了sum，那么就没必要继续递归下去了。
2. 当本层的开始位置到m到9的范围内的数字无法构成一个长度为k的组合时就没必要继续循环下去了，直接退出本层循环。

var combinationSum3 = function(k, n) {
    let res = [];
    let path = [];
    let dfs = function (m, k, sum) {
        if (sum > n) { // 剪枝操作
            return; // 如果path.size() == k 但sum != targetSum 直接返回
        }
        // 递归终止条件
        if (path.length === k) {
            if (sum === n)
                res.push(Array.from(path));
            return;
        }
        // 剪枝
        for (let i = m; i <= 9 -k + path.length + 1; i++) {
            path.push(i);
            dfs(i + 1, k, sum + i);
            path.pop();
        }
    }
    dfs(1, k, 0);
    return res;
};