Day25【回溯算法】216.组合总和III、17.电话号码的字母组合

本来周日该休息的，但是因为周五歇了一天，所以周六补周五的，今天补周六的

216.组合总和III 

题目链接/文章讲解/视频讲解 

本题和77. 组合很像，同样是在遍历的过程中记录路径、同样是收集组合，唯一的不同是到达叶子节点后，我们还需要判断是否应该将本次记录的路径存储下来

在这里，当我们收集到了 k 个元素的组合了，表示我们此时到达了叶子节点，此时应该判断一下这 k 个元素的组合是否等于 n， 只有等于 n，才满足题干要求“收集相加之和为 n 的 k 个数的组合”，此时才需要放进结果集

class Solution {
public:
    vector<vector<int> > result;
    vector<int> path;
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n, k, 1);
        return result;
    }
    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k)   // 终止条件
        {
            if (accumulate(path.begin(), path.end(), 0) == n)    // 判断是否需要储存本次记录
                result.push_back(path); // 存放结果
            return; // 往回走
        }
        for (int i = startIndex; i <= 9 - k + path.size() + 1; ++i) { // 到达了一个节点后，可选择的路径由startIndex控制
            // 注意剪枝操作
            path.push_back(i);  // 记录选择的路径
            backtracking(n, k, i + 1);  // 前往下一个节点
            path.pop_back();    // 撤销记录
        }
        return;
    }
};

剩下的代码和77. 组合一模一样

我们还可以做适量的优化

• 利用一个全局变量 sum 记录当前收集到的组合的元素和，因为组合中的元素为正数，则当 sum 大于了 targetSum（就是上面的n，换了个变量名而已），就直接往上返回了(因为再往下走到叶子节点的时候，组合中的元素和一定也大于 targetSum)
• 到达叶子节点的时候，直接用全局变量 sum 去和 targetSum 进行对比，看看是否应该将这次收集到的路径加入结果
• 记录路径和撤销记录的时候，除了需要维护路径 path，还需要维护组合的元素和 sum

class Solution {
public:
    vector<vector<int> > result;
    vector<int> path;
    int sum = 0;
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n, k, 1);
        return result;
    }
    void backtracking(int targetSum, int k, int startIndex) {
        if (sum > targetSum)    // 如果此时的和已经大于目标和了，后面的路不用走了直接返回
            return;
        if (path.size() == k)   // 终止条件
        {
            if (sum == targetSum)
                result.push_back(path); // 存放结果
            return; // 往回走
        }
        for (int i = startIndex; i <= 9 - k + path.size() + 1; ++i) { // 到达了一个节点后，可选择的路径由startIndex控制
            // 注意剪枝操作
            path.push_back(i);  // 记录选择的路径
            sum += i;    // 记录时需要维护sum
            backtracking(targetSum, k, i + 1);  // 前往下一个节点
            path.pop_back();    // 撤销记录
            sum -= i;    // 撤销时也需要维护sum
        }
        return;
    }
};

17.电话号码的字母组合 

题目链接/文章讲解/视频讲解 

本题的难点是构造出树形结构 

比如输入"23"，我们首先选择字符'2'所对应的字母'a'、'b'、'c'，三种选择，选好了字符'2'，接下来就要选择字符'3'所对应的字母'd'、'e'、'f'。当所有字符对应的字母都被选到了，说明到达了叶子节点，我们可以收集结果了 

从图中可以看出，我们的结果集还是在记录“边”，即记录的是每次取哪个字母，因此我们套用记录边的回溯模板

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;    // 往回走
    }
 
    for (路径：所有可选择的路径) {
        添加记录;
        backtracking(路径，其他参数); // 前往下一个节点
        撤销记录;    // 回溯
    }
    return;    // 往回走
}

还是对着模板一步一步看：

终止条件是什么？当输入字符串中的所有字符都取到了一个对应的字母，即取到了字符串长度个数的字母，则说明到达终止条件需要收集结果了

我们需要一个记录取到字母的全局变量 path，一个用于收集结果的全局变量 result。此外，我们还需要一个map用来表示数字与字母的映射关系 

const string letterMap[10] = {
    "",       // 0
    "",       // 1
    "abc",    // 2
    "def",    // 3
    "ghi",    // 4
    "jkl",    // 5
    "mno",    // 6
    "pqrs",   // 7
    "tuv",    // 8
    "wxyz"    // 9
};
vector<string> result;
string path;

void backtracking(const string & digits) {
    if (path.size() == digits.size()) {    // 到终止条件
        result.push_back(path);    // 收集结果
        return;    // 往回走
    }
 
    for (路径：所有可选择的路径) {
        添加记录;
        backtracking(路径，其他参数); // 前往下一个节点
        撤销记录;    // 回溯
    }
    return;    // 往回走
}

如果没有到达叶子节点，即跨过终止条件的 if 语句，此时我们就相当于站在了一个节点上，接下来应该去看看下一步有哪些可以选择的路径，即有哪些字母可以取。从题意可以看出，有哪些可以取的字母是由当前遍历的字符是什么所决定的，因此，我们通过一个传入参数 index 表示当前节点正在遍历的字符索引，从而明确在该节点能够选择的路径。不同的 index 表示不同的正在遍历的字符，也标识不同的节点

 

知道了当前正在遍历的字符，自然就能知道有哪些可以选择的路径，进而做出选择从而继续处理下一个节点

如何前往下一个节点？看图，这里前往下一个节点表示从下一个字符对应的映射字母中取，下一个处理的字符索引比当前节点处理的字符索引大1，向回溯函数传入不同的 index 表示回溯函数走到了不同的节点（别忘了不同 index 能代表不同节点）

void backtracking(const string & digits, int index) {
    if (path.size() == digits.size()) {    // 到终止条件
        result.push_back(path);    // 收集结果
        return;    // 往回走
    }
    string paths = letterMap[digits[index] - '0'];    // 站在当前节点，可以选择的路径
    for (auto p : paths) {
        path.push_back(p);    // 添加记录
        backtracking(digits, index + 1);    // 前往下一个节点
        path.pop_back();    // 撤销记录
    }
    return;    // 往回走
}

完整代码

class Solution {
private:
    const string letterMap[10] = {
        "",
        "",
        "abc",
        "def",
        "ghi",
        "jkl",
        "mno",
        "pqrs",
        "tuv",
        "wxyz"
    };
    vector<string> result;
    string path;
public:
    vector<string> letterCombinations(string digits) {
        if (digits.size() == 0)
            return result;
        backtracking(digits, 0);
        return result;
    }
    void backtracking(const string & digits, int index) {
        if (path.size() == digits.size()) { // 到终止条件
            result.push_back(path); // 收集结果
            return; // 返回上一层
        }
        string paths = letterMap[digits[index] - '0'];
        for (auto p : paths) {
            path.push_back(p);
            backtracking(digits, index + 1);
            path.pop_back();
        }
        return;
    }
};

注意，在主函数中调用需要先判断输入的字符长度是否为空，如果不判定，会出现以下错误

---

回顾总结 

要注意以下关键点

1. 怎么抽象为树结构
2. 需要记录的是节点还是边，这决定了套用哪个回溯模板 
3. 需要哪些辅助记录用的全局变量
4. 终止条件及收集结果的逻辑
5. 怎么获取在当前节点能够选择的路径
6. 怎么前往下一个节点
7. 注意添加记录以及擦除记录的回溯逻辑