回溯算法-组合问题

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

解题思路与代码实现

class Solution {private List<List<Integer>> res = new ArrayList<>();    // 保存最终结果private LinkedList<Integer> path = new LinkedList<>();    // 暂存某一条解空间树中的路径public List<List<Integer>> combine(int n, int k) {backtracking(n, k, 1);    // 递归return res;}/*** 递归，纵向探索解空间树** @param start 起始位置*/private void backtracking(int n, int k, int start) {// path已存了k个元素，停止递归并合并结果if (path.size() == k) {// 使用深拷贝res.add(new ArrayList<>(path));return;}// for循环：横向枚举该层的所有可能，// 剪枝：例当n=4，k=3时，目前已经选取的元素为0（path.size为0），n - (k - 0) + 1 即 4 - ( 3 - 0) + 1 = 2for (int i = start; i <= n - (k - path.size()) + 1; i++) {path.addLast(i);backtracking(n, k, i+1);    // 递归path.removeLast(); // 回溯，撤销处理结果}}
}

踩坑点

如何进行剪枝优化

17. 电话号码的字母组合

问题描述

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

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

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

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 0 <= digits.length <= 4
• digits[i] 是范围 ['2', '9'] 的一个数字。

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

解题思路与代码实现

class Solution {private static Map<String, String[]> map = new HashMap<>(); // 存储数字和字母的映射private List<String> res = new ArrayList<>();   // 保存最终结果static {// 初始化数字和字母的映射map.put("2", new String[]{"a", "b", "c"});map.put("3", new String[]{"d", "e", "f"});map.put("4", new String[]{"g", "h", "i"});map.put("5", new String[]{"j", "k", "l"});map.put("6", new String[]{"m", "n", "o"});map.put("7", new String[]{"p", "q", "r", "s"});map.put("8", new String[]{"t", "u", "v"});map.put("9", new String[]{"w", "x", "y", "z"});}public List<String> letterCombinations(String digits) {if (!digits.isEmpty()) {    // 字符串判空backtracking(digits, 0, new StringBuilder());}return res;}/*** 回溯函数* @param digits 数字字符串* @param index 当前层数字对应数字字符串中的下标* @param builder 动态字符串*/private void backtracking(String digits, int index, StringBuilder builder) {if (builder.toString().length() == digits.length()) {   // 收集到digits.length()个字母// 合并结果res.add(builder.toString());return;}// 获取当成层对应的字母String[] letters = map.get(digits.charAt(index) + "");for (int i = 0; i < letters.length; i++) {builder.append(letters[i]); // 末尾拼接新的字母backtracking(digits, index + 1, builder);   // 递归builder.deleteCharAt(builder.length() - 1); // 移除末尾拼接的字母}}
}

踩坑点

无

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
• 2 <= candidates[i] <= 40
• candidates 的所有元素 互不相同
• 1 <= target <= 40

解题思路与代码实现

class Solution {private List<List<Integer>> res = new ArrayList<>();    // 保存最终结果private LinkedList<Integer> path = new LinkedList<>();    // 暂存某一条解空间树中的路径private int currentSum = 0; // path中的元素和public List<List<Integer>> combinationSum(int[] candidates, int target) {Arrays.sort(candidates);    // 升序排序backtracking(candidates, target, 0);return res;}/*** 回溯函数* 本题区别于组合总和，每层的节点都有n个分叉（n为candidates候选数组的长度）** @param start 起始下标*/private void backtracking(int[] candidates, int target, int start) {if (target == currentSum) {   // 收集到和为target的一组数// 合并结果(深拷贝)res.add(new ArrayList<>(path));return;}// 当前每层的节点都有n个分叉，代表candidates数组各个元素// 剪枝：如果 currentSum + candidates[i] > target 就终止遍历for (int i = start; i < candidates.length && currentSum + candidates[i] <= target; i++) {path.addLast(candidates[i]);currentSum += candidates[i];// 递归，起始下标为i有去重的效果，如样例1，计算出2,2,2后，不算重复计算3,2,2backtracking(candidates, target, i);currentSum -= candidates[i];    // 回溯path.removeLast();  // 回溯}}
}

踩坑点

需要设置变量记录当前path列表中的元素和

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

解题思路与代码实现

class Solution {private List<List<Integer>> res = new ArrayList<>();    // 保存最终结果private LinkedList<Integer> path = new LinkedList<>();    // 暂存某一条解空间树中的路径private int currentSum = 0; // path中的元素和public List<List<Integer>> combinationSum2(int[] candidates, int target) {Arrays.sort(candidates);    // 升序排序backtracking(candidates, target, 0);return res;}/*** 回溯函数* 这道题目和39.组合总和 (opens new window)如下区别：* 1.本题candidates 中的每个数字在每个组合中只能使用一次。* 2.本题数组candidates的元素是有重复的，而39.组合总和 (opens new window)是无重复元素的数组candidates* 踩坑：解空间树层去重：如用例candidates = [1,1,2,4]，target = 5，当i=0时，有[1,4]，当i=1时，无需在重复计算，跳过本轮循环（剪枝）* @param start 起始下标*/private void backtracking(int[] candidates, int target, int start) {// currentSum>target不会执行if和for循环if (target == currentSum) {   // 收集到和为target的一组数// 合并结果(深拷贝)res.add(new ArrayList<>(path));return;}// 剪枝：如果 currentSum + candidates[i] > target 就终止遍历for (int i = start; i < candidates.length && currentSum + candidates[i] <= target; i++) {// 特别测试用例：1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 没有这一步可能会超时// 如果有相邻的重复元素，如candidates[i]== candidates[i - 1]，candidates[i-1]试过了则andidates[i]不需要重复计算，需要剪枝if (i > start && candidates[i] == candidates[i - 1]) {continue;}path.addLast(candidates[i]);currentSum += candidates[i];// 递归，起始下标为i有去重的效果，避免重复计算backtracking(candidates, target, i + 1);currentSum -= candidates[i];    // 回溯path.removeLast();  // 回溯}}
}

踩坑点

重复元素需要避免重复计算，否则会超时

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

解题思路与代码实现

class Solution {private Integer currentSum = 0;    // 暂存path的元素和private List<List<Integer>> res = new ArrayList<>();    // 保存最终结果private LinkedList<Integer> path = new LinkedList<>();    // 暂存某一条解空间树中的路径/*** 找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：* 只使用数字1到9* 每个数字 最多使用一次*/public List<List<Integer>> combinationSum3(int k, int n) {backtracking(n, k, 1);return res;}/*** 递归，纵向探索解空间树** @param start 起始位置*/private void backtracking(int n, int k, int start) {// path已存了k个元素，停止递归并合并结果if (path.size() == k ) {if (currentSum == n){   // 和为n的才保存到结果中// 使用深拷贝res.add(new ArrayList<>(path));}return;}// for循环：横向枚举该层的所有可能，for (int i = start; i <= 9 && currentSum + i <= n; i++) {path.addLast(i);currentSum += i;backtracking(n, k, i + 1);    // 递归currentSum -= i;path.removeLast(); // 回溯，撤销处理结果}}
}

踩坑点

无