回溯算法将组合问题一网打尽

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第3天，点击查看活动详情

1. 组合

1.1 问题描述

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

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

1.2 要求

示例 1：

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

示例 2：

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

1.3 思路

既然是树形问题上的深度优先遍历，因此首先画出树形结构。例如输入：n = 4, k = 2，我们可以发现如下递归结构：

如果组合里有 1 ，那么需要在 [2, 3, 4] 里再找 1 个数；如果组合里有 2 ，那么需要在 [3, 4] 里再找 1数。注意：这里不能再考虑 1，因为包含 1 的组合，在第 1 种情况中已经包含。依次类推（后面部分省略），以上描述体现的递归结构是：在以 n 结尾的候选数组里，选出若干个元素。画出递归结构如下图：

for循环每次从startIndex开始遍历，然后用path保存取到的节点i。

代码如下：

for(let i = startIndex; i <= n; i++) {
    path.push(i); // 处理节点
    backtracking(i + 1, path); // 递归
    path.pop(); // 回溯，撤销处理结果
}

可以看出backtracking（递归函数）通过不断调用自己一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回。

backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。

1.4 代码

/**
 * @param {number} n
 * @param {number} k
 * @return {number[][]}
 */
var combine = function(n, k) {
    const paths = [];

    const backtracking = (startIndex, path = []) => {
        // 剪枝
        if (path.length + n - startIndex + 1 < k) return;

        if (path.length === k) {
            paths.push([...path]); // 存放结果
            return;
        }

        for(let i = startIndex; i <= n; i++) {
            path.push(i); // 处理节点
            backtracking(i + 1, path); // 递归
            path.pop(); // 回溯，撤销处理结果
        }
    }
    backtracking(1);

    return paths;
};

2. 电话号码的字母组合

2.1 问题描述

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

2.2 要求

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

2.3 思路

既然是树形问题上的深度优先遍历，因此首先画出树形结构。例如输入：digits = "23"，我们可以发现如下递归结构：

如果一开始选了a，则后面就要再def中选一个。
依次类推（后面部分省略）。

首先使用数组表存储每个数字对应的所有可能的字母，然后进行回溯操作。

回溯过程中维护一个字符数组，表示已有的字母排列（如果未遍历完电话号码的所有数字，则已有的字母排列是不完整的）。该字符数组初始为空。每次取电话号码的一位数字，从数组中获得该数字对应的所有可能的字母，并将其中的一个字母插入到已有的字母排列后面，然后继续处理电话号码的后一位数字，直到处理完电话号码中的所有数字，即得到一个完整的字母排列。然后进行回退操作，遍历其余的字母排列。

2.4 代码

/**
 * @param {string} digits
 * @return {string[]}
 */
var letterCombinations = function(digits) {
    const letterMap = [
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
    ];
    const length = digits.length;
    const paths = [];

    if (!length) return paths;

    const backtracking = (startIndex, path = []) => {
        if (startIndex === length) {
            paths.push(path.join('')); // 存放结果
            return;
        }

        const letters = letterMap[parseInt(digits[startIndex])];
        for(let j = 0; j < letters.length; j++) {
            path.push(letters[j]); // 处理节点
            backtracking(startIndex + 1, path); // 递归
            path.pop(); // 回溯，撤销处理结果
        }
    }

    backtracking(0);
    
    return paths;
};

3. 组合总和

3.1 问题描述

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

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

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

3.2 要求

示例 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
输出: []

3.3 思路

既然是树形问题上的深度优先遍历，因此首先画出树形结构。例如输入：candidates = [2, 3, 6, 7]，target = 7，我们可以发现如下递归结构：

候选数组里有 2，如果找到了组合总和为 7 - 2 = 5 的所有组合，再在之前加上 2 ，就是 7 的所有组合；
同理考虑 3，如果找到了组合总和为 7 - 3 = 4 的所有组合，再在之前加上 3 ，就是 7 的所有组合，依次这样找下去。

说明

以 target = 7 为根结点，创建一个分支的时 做减法 ；
每一个箭头表示：从父亲结点的数值减去边上的数值，得到孩子结点的数值。边的值就是题目中给出的 candidate 数组的每个元素的值；
减到 0 或者负数的时候停止，即：结点 0 和负数结点成为叶子结点；
所有从根结点到结点 0 的路径（只能从上往下，没有回路）就是题目要找的一个结果。

这棵树有 4 个叶子结点的值 0，对应的路径列表是 [[2, 2, 3], [2, 3, 2], [3, 2, 2], [7]]，而示例中给出的输出只有 [[7], [2, 2, 3]]。即：题目中要求每一个符合要求的解是 不计算顺序 的。下面我们分析为什么会产生重复。

产生重复的原因是：在每一个结点，做减法，展开分支的时候，由于题目中说 每一个元素可以重复使用，我们考虑了 所有的 候选数，因此出现了重复的列表。

一种简单的去重方案是借助哈希表的天然去重的功能，但实际操作一下，就会发现并没有那么容易。

可不可以在搜索的时候就去重呢？答案是可以的。遇到这一类相同元素不计算顺序的问题，我们在搜索的时候就需要 按某种顺序搜索。具体的做法是：每一次搜索的时候设置 下一轮搜索的起点 begin。

3.4 代码

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function(candidates, target) {
  const length = candidates.length;
  const paths = [];

  const backtracking = (startIndex, target, path = []) => {

    if (target === 0) {
      paths.push([...path]);
      return;
    }

    for(let i = startIndex; i < length; i++) {
      if (target < candidates[i]) continue; // 剪枝
      path.push(candidates[i]); // 处理节点
      backtracking(i, target - candidates[i], path);
      path.pop(); // 回溯，撤销处理结果
    }
  }

  backtracking(0, target, []);

  return paths;
};

4. 组合总和 II

4.1 问题描述

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

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

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

4.2 要求

示例 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]
]

4.3 思路

这道题与上一问的区别在于：

上题：candidates 中的数字可以无限制重复被选取；
本题：candidates 中的每个数字在每个组合中只能使用一次。

相同点是：相同数字列表的不同排列视为一个结果。

由上题我们知道，数组 candidates 有序，也是 深度优先遍历 过程中实现剪枝的前提。将数组先排序的思路来自于这个问题：去掉一个数组中重复的元素。很容易想到的方案是：先对数组 升序排序，重复的元素一定不是排好序以后相同的连续数组区域的第 1 个元素。也就是说，剪枝发生在：同一层数值相同的结点第 2、3 ... 个结点，因为数值相同的第 1 个结点已经搜索出了包含了这个数值的全部结果，同一层的其它结点，候选数的个数更少，搜索出的结果一定不会比第 1 个结点更多，并且是第 1 个结点的子集。

4.4 代码

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum2 = function(candidates, target) {
  const length = candidates.length;
  const paths = [];
  candidates.sort((a, b) => a - b);
  
  const backtracking = (startIndex, target, path = []) => {

    if (target === 0) {
      paths.push([...path]);
      return;
    }

    for(let i = startIndex; i < length; i++) {
       // 大剪枝：减去 candidates[i] 小于 0，减去后面的 candidates[i + 1]、candidates[i + 2] 肯定也小于 0
      if (target < candidates[i]) continue; 
      
       // 小剪枝：同一层相同数值的结点，从第 2 个开始，候选数更少，结果一定发生重复，因此跳过
      if (i > startIndex && candidates[i] == candidates[i - 1]) continue;

      path.push(candidates[i]); // 处理节点
      backtracking(i + 1, target - candidates[i], path);
      path.pop(); // 回溯，撤销处理结果
    }
  }

  backtracking(0, target, []);

  return paths;
};

5. 组合总和 III

5.1 问题描述

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

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

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

5.2 要求

示例 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，没有有效的组合。

5.3 思路

关于组合总和的问题，之前我们已经完成过组合总和和组合总和 II 两道题了。

这题相对容易，就不再赘述了。

5.4 代码

/**
 * @param {number} k
 * @param {number} n
 * @return {number[][]}
 */
var combinationSum3 = function(k, n) {
  const candidates = [1, 2, 3, 4, 5, 6, 7, 8, 9];
  const length = 9;
  const paths = [];
  
  const backtracking = (startIndex, target, k, path = []) => {

    if (k === 0) {
      if (target === 0) paths.push([...path]);
      return;
    }

    for(let i = startIndex; i < length; i++) {
       // 大剪枝：减去 candidates[i] 小于 0，减去后面的 candidates[i + 1]、candidates[i + 2] 肯定也小于 0
      if (target < candidates[i]) continue; 

      path.push(candidates[i]); // 处理节点
      backtracking(i + 1, target - candidates[i], k - 1, path);
      path.pop(); // 回溯，撤销处理结果
    }
  }

  backtracking(0, n, k, []);

  return paths;
};