216.组合总和III 

216. 组合总和 III - 力扣（LeetCode）

代码随想录 (programmercarl.com)

和组合问题有啥区别？回溯算法如何剪枝？| LeetCode：216.组合总和III_哔哩哔哩_bilibili

找出所有相加之和为 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，没有有效的组合。

第一反应和昨天的77.组合的解法相同，不过对于剪枝部分以及n和k怎么应用我还是有点不懂。

看了卡哥的题解，发现自己对于题目的理解还是有些偏差。首先，该题题意可以理解为：在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合。K相当于树的深度。

回溯三部曲：

1、确定参数和返回值：一个一维数组path来存放符合条件的结果，一个二位数组result来存放结果集：

List<List<Integer>> result = new ArrayList<>(); // 用于存储最终结果的列表
LinkedList<Integer> path = new LinkedList<>(); // 用于存储当前组合的列表

还需要的参数有：n,k,path路径中元素的综合sum，下一层for循环搜索的起始位置startIndex:
 

private void backTracking(int targetSum, int k, int startIndex, int sum) {}

2、确定终止条件：path.size和k相等的时候终止，sum和targetSum相等的时候用result收集当前结果：

if (path.size() == k) {if (sum == targetSum) result.add(new ArrayList<>(path));return;
}

3、单层搜索的过程：

for (int i = startIndex; i <= 9 ; i++) {path.add(i); // 将当前数字加入组合列表sum += i; // 更新累加和backTracking(targetSum, k, i + 1, sum); // 递归搜索下一个数字path.removeLast(); // 回溯：移除最后加入的数字，以便尝试其他可能的数字sum -= i; // 回溯：减去移除的数字，恢复累加和
}

 剪枝：

1、已选元素的值已经大于总和，就没有必要再往后遍历了

2、for循环的位置可以剪枝：i <= 9 - (k - path.size()) + 1就可以了。

综合代码：

class Solution {List<List<Integer>> result = new ArrayList<>(); // 用于存储最终结果的列表LinkedList<Integer> path = new LinkedList<>(); // 用于存储当前组合的列表public List<List<Integer>> combinationSum3(int k, int n) {backTracking(n, k, 1, 0); // 调用回溯算法寻找符合条件的组合return result; // 返回最终结果}private void backTracking(int targetSum, int k, int startIndex, int sum) {// 减枝：如果当前累加的和已经大于目标值，则停止当前路径的搜索if (sum > targetSum) {return;}// 如果当前组合的元素数量已经达到要求，且当前累加和等于目标值，将当前组合加入结果列表if (path.size() == k) {if (sum == targetSum) result.add(new ArrayList<>(path));return;}// 减枝：根据剩余可用数字的数量和目标组合元素数量，确定可用的起始数字范围for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {path.add(i); // 将当前数字加入组合列表sum += i; // 更新累加和backTracking(targetSum, k, i + 1, sum); // 递归搜索下一个数字path.removeLast(); // 回溯：移除最后加入的数字，以便尝试其他可能的数字sum -= i; // 回溯：减去移除的数字，恢复累加和}}
}

从图中可以看出，遍历的深度就是【2、3】数组的长度，叶子节点就是我们要收集的结果。

回溯三部曲：

1、确定参数：全局变量：一个字符串S手机叶子节点的结果，然后用一个字符串数组result把结果收集起来；局部变量：string digits和index,index用来遍历digits的同时记录遍历到digits的第几个数字；

2、确定终止条件：index=digits.size

3、确定单层遍历的逻辑：取index指向的数字，取该数字对应的字母：提前把index中的数字和其对应的字母集用map存储起来

综合代码：

class Solution {// 设置全局列表存储最后的结果List<String> list = new ArrayList<>();// 主函数，传入数字字符串，返回所有可能的字母组合public List<String> letterCombinations(String digits) {if (digits == null || digits.length() == 0) {return list; // 如果输入为空，则直接返回结果列表}// 初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};// 迭代处理backTracking(digits, numString, 0);return list;}// 每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuilderStringBuilder temp = new StringBuilder();// 比如 digits 如果为 "23"，num 为 0，则 str 表示 2 对应的 "abc"public void backTracking(String digits, String[] numString, int num) {// 遍历全部一次记录一次得到的字符串if (num == digits.length()) {list.add(temp.toString()); // 当数字索引已经达到 digits 字符串的长度时，将当前拼接好的字符串加入结果列表return;}// str 表示当前 num 对应的字符串String str = numString[digits.charAt(num) - '0'];for (int i = 0; i < str.length(); i++) {temp.append(str.charAt(i)); // 将当前字符追加到临时 StringBuilder 中backTracking(digits, numString, num + 1); // 递归调用，处理下一个数字temp.deleteCharAt(temp.length() - 1); // 剔除末尾的字符，为下一个迭代做准备}}
}