代码随想录算法训练营第二十五天| 回溯算法 216.组合总和III 17.电话号码的字母组合

216.组合总和III

题目链接

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

• 只使用数字1到9
• 每个数字 最多使用一次
  返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

思路：因为做过77那道组合题，拿到这道题的第一想发就是回溯，所以套用回溯模板解决了这道题。

这道题主要有两个判断完成终止条件：值满足和长度满足的时候，返回

class Solution {
public:

    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;
    void backtracking(int n, int k, int startIndex) {
        if (sum == n && path.size() == k) { 
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i <= 9; i++) {
            sum += i;
            path.push_back(i);
            backtracking(n, k, i+1);  // 注意i+1调整startIndex
            sum -= i;
            path.pop_back();
        }
    }

    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n, k, 1);
        return result;
    }
};

题目中的sum可以省略，直接用 n -= i 来进行判断，当n为0的时候就是满足条件的时候，返回。还要强调一下，回溯法中递归函数参数很难一次性确定下来，一般先写逻辑，需要啥参数了，填什么参数。

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

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

if (sum > targetSum) { // 剪枝操作
    return;
}

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

这里需要看组合那道题的详细解释，然后模拟出至多这个条件，就很容易想到。

总体代码如下：

class Solution {
private:
    vector<vector<int>> result; // 存放结果集
    vector<int> path; // 符合条件的结果
    void backtracking(int targetSum, int k, int sum, int startIndex) {
        if (sum > targetSum) { // 剪枝操作
            return; // 如果path.size() == k 但sum != targetSum 直接返回
        }
        if (path.size() == k) {
            if (sum == targetSum) result.push_back(path);
            return;
        }
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) { // 剪枝
            sum += i; // 处理
            path.push_back(i); // 处理
            backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
            sum -= i; // 回溯
            path.pop_back(); // 回溯
        }
    }

public:
    vector<vector<int>> combinationSum3(int k, int n) {
        result.clear(); // 可以不加
        path.clear();   // 可以不加
        backtracking(n, k, 0, 1);
        return result;
    }
};

总结： 现在对回溯算法看着模板有一定的感觉了，但是对剪枝操作还没有完全吃透，所以在接下来的刷题过程中，还是要自己多想剪枝操作。各种条件都要理解清除。

17.电话号码的字母组合

题目链接

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

思路： 根据哈希法构建键盘对应的数字字母映射。然后回溯遍历得到结果

1、确定回溯函数参数
首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量我依然定义为全局。
再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

vector<string> result;
string s;
void backtracking(const string& digits, int index)

2、确定终止条件
例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。
那么终止条件就是如果index 等于 输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。
然后收集结果，结束本层递归。

if (index == digits.size()) {
    result.push_back(s);
    return;
}

3、确定单层遍历逻辑
首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）。

class Solution {
public:
    // 将电话映射成一个二维数组，这里使用二维数组
    vector<string> letterMap {
        "", //0
        "", // 1
        "abc", //2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz" // 9
    };

    string s; // 单次满足
    vector<string> result;
    void backtracking(const string& digits, int index) {
        if (index == digits.size()) {
            result.push_back(s);
            return;
        }
        // ascii码直接将对应的字符转成数字。如果是’0’到’9’ 减去’0’就是想要的整数的。
        int digit = digits[index] - '0';  
        string letters = letterMap[digit];
        for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);
            backtracking(digits, index+1);
            s.pop_back();
        }
    }

    vector<string> letterCombinations(string digits) {
        if (digits.size() == 0) {
            return result;
        }

        backtracking(digits, 0);
        return result;
    }
};

总结一开始拿到题目不知道怎么做，虽然是回溯专题，也想到了哈希法映射整个键盘，但是在单层逻辑和终止条件没有做出来。