力扣刷题day22|216组合总和 III、17电话号码的字母组合

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

思路

和普通的组合问题一样，多一步就是要判断当前的和是否超过了

回溯法三部曲

1. 递归函数的返回值以及参数

• k（int）就是题目中要求k个数的集合。
• sum（int）为已经收集的元素的总和，也就是path里元素的总和。
• startIndex（int）为下一层for循环搜索的起始位置。

回溯法中递归函数参数很难一次性确定下来，一般先写逻辑，需要啥参数了，填什么参数。

void backtracking(int k, int n, int startIndex)

2. 确定终止条件

什么时候终止呢？

在上面已经说了，k其实就已经限制树的深度，因为就取k个元素，树再往下深了没有意义。

所以如果path.size() 和 k相等了，就终止。

如果此时path里收集到的元素和（sum） 和targetSum（就是题目描述的n）相同了，就用result收集当前的结果。

// 找到最后一个元素就中止
if (path.size() == k) {
    if (sum == n) {
        res.add(new ArrayList<>(path));
    }
    return;
}

3. 单层搜索过程

集合固定的就是9个数[1,…,9]，所以for循环固定i<=9

for (int i = startIndex; i <= 9; i++) {
    sum += i;
    path.add(i); // 把当前元素加入path
    backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
    sum -= i; // 回溯
    path.removeLast(); // 回溯
}

剪枝

已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉。

那么剪枝的地方可以放在递归函数开始的地方，剪枝代码如下：

// 剪枝，现在的和如果已经大于n就可以回溯了
if (sum > n) {
    return;
}

for循环的范围也可以剪枝，i <= 9 - (k - path.size()) + 1就可以了

for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++)

完整代码

public List<List<Integer>> combinationSum3(int k, int n) {
    backtracking(k, n, 1);
    return res;
}

LinkedList<Integer> path = new LinkedList<>();
List<List<Integer>> res = new ArrayList<>();
int sum = 0;
void backtracking(int k, int n, int startIndex) {
    // 剪枝，现在的和如果已经大于n就可以回溯了
    if (sum > n) {
        return;
    }
    // 找到最后一个元素就中止
    if (path.size() == k) {
        if (sum == n) {
            res.add(new ArrayList<>(path));
        }
        return;
    }
    // 单层
    for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
        sum += i;
        path.add(i); // 把当前元素加入path
        backtracking(k, n, i + 1);
        sum -= i; // 回溯
        path.removeLast(); // 回溯
    }

}

17. 电话号码的字母组合

力扣题目链接

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

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

示例 1：

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

示例 2：

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

示例 3：

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

思路

我们有几个数字就要用几次for循环，每次for循环就是遍历当前数字的代表的字母，一开始可能理解错误为需要自己找到有多少种数字组合，再从找到的数字组合中遍历出每种组合可能代表的字母组合。

输入"23"，就是两层for，如果输入"233"呢，那么就三层for循环，如…果"2333"呢，就四层for循环…因此我们想到用回溯法

难点：数字和字母如何映射

可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射，我这里定义一个二维数组

//初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
String[] numString = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
};

回溯三部曲

1. 确定回溯函数参数

首先需要一个全局的字符串s来收集叶子节点的结果，然后用一个全局的字符串数组result保存起来，

参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

//设置全局列表存储最后的结果
List<String> res = new ArrayList<>();
//每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuild
StringBuilder s = new StringBuilder();
void backtracking(String digits, int index) {

2. 确定终止条件

例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。

那么终止条件就是如果index 等于输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。

然后收集结果，结束本层递归。

if (index == digits.length()) {
    res.add(s.toString());
    return;
}

3. 确定单层遍历逻辑

首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集），然后for循环来处理这个字符集

// 找到当前数字在字典中的下标
int curNum = digits.charAt(index) - '0';
// 取到该数字代表的字母集
String letters = numString[curNum];
// 取字母
for (int i = 0; i < letters.length(); i++) {
    s.append(letters.charAt(i));
    backtracking(digits, index + 1); // 递归，注意index+1，一下层要处理下一个数字了
    s.deleteCharAt(s.length() - 1); // 回溯
}

注意：输入1 * #按键等等异常情况

代码中最好考虑这些异常情况，但题目的测试数据中应该没有异常情况的数据，所以我就没有加了。

但是要知道会有这些异常，如果是现场面试中，一定要考虑到！

完整代码：

//设置全局列表存储最后的结果
List<String> res = new ArrayList<>();
//每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuild
StringBuilder s = new StringBuilder();
//初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
String[] numString = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
};

public List<String> letterCombinations(String digits) {
    if (digits.length() == 0) {
        return res;
    }
    backtracking(digits, 0);
    return res;
}

void backtracking(String digits, int index) {
    if (index == digits.length()) {
        res.add(s.toString());
        return;
    }

    // 找到当前数字在字典中的下标
    int curNum = digits.charAt(index) - '0';
    // 取到该数字代表的字母集
    String letters = numString[curNum];
    // 取字母
    for (int i = 0; i < letters.length(); i++) {
        s.append(letters.charAt(i));
        backtracking(digits, index + 1); // 递归，注意index+1，一下层要处理下一个数字了
        s.deleteCharAt(s.length() - 1); // 回溯
    }
}