代码随想录算法训练营day25

题目：216.组合总和III、17.电话号码的字母组合

参考链接：代码随想录

216.组合总和III

思路：首先分析过程，在1-9中选择k个数，首先确定选择的第1个数，比如1，然后在2-9中选择剩下的k-1个数，确保选择的k个数递增，这样就不会重复。为方便，我们在递归过程中不断减少总和n的值。返回条件为选择的路径长度为k，且只有当n==0时才将结果路径添加到ans中；for循环用于确认选择的第1个数，如果选择的第一个数比剩下所需的总和n还要大，则不可能选出结果，直接返回；递归用于选择剩下的数，我们将第二个参数减去已经选择的第一个数，即n-i，注意选择完后回溯。时间复杂度O(n*2^n)。

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void backtracking(int k,int n,int begin){
        if(path.size()==k){
            if(n==0){//只有递减到0才加入结果
                ans.push_back(path);
            }
            return;
        }
        for(int i=begin;i<=9;i++){
            if(n<i){//第一个选择的数i比还需要剩下的所需总和n还要大，说明不可能,直接返回
                return;
            }
            path.push_back(i);
            backtracking(k,n-i,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(k,n,1);
        return ans;
    }
};

思考剪枝方法，我们其实已经在for循环中的if判断中完成了剪枝，简化一下代码可以把 i<=n 放到for循环的条件判断中：

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void backtracking(int k,int n,int begin){
        if(path.size()==k){
            if(n==0){//只有递减到0才加入结果
                ans.push_back(path);
            }
            return;
        }
        for(int i=begin;i<=9&&i<=n;i++){
            path.push_back(i);
            backtracking(k,n-i,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(k,n,1);
        return ans;
    }
};

标答用了一个sum记录目前路径的和，我们使用了递减的方式，直接省略了这个步骤。标答还进行了根据路径长度的剪枝，这里我们忘记了。
标答：

class Solution {
private:
    vector<vector<int>> result; // 存放结果集
    vector<int> path; // 符合条件的结果
    void backtracking(int targetSum, int k, int sum, int startIndex) {
        if (sum > targetSum) { // 剪枝操作
            return; 
        }
        if (path.size() == k) {
            if (sum == targetSum) result.push_back(path);
            return; // 如果path.size() == k 但sum != targetSum 直接返回
        }
        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和其对应的字母保存到一个map中。结束条件为若digits为空，直接结束，或者目前路径长度等于digits长度，此时将路径添加到结果中；对for循环，考虑选择的开始位置begin，对开始位置开始遍历；递归过程遍历后续的字母选择，注意回溯操作。时间复杂度O(n*2^n)。

class Solution {
public:
    vector<string> ans;
    string path;
    void backtracking(map<char,vector<char>> &mp,string digits,int begin){
        if(digits.empty()){//没有选择，直接返回
            return;
        }
        if(path.size()==digits.size()){
            ans.push_back(path);
            return;
        }
        for(int i=begin;i<=digits.size()-1;i++){
            for(char c:mp[digits[i]]){//还要对第一个数字对应的字母依次遍历
                path.push_back(c);
                backtracking(mp,digits,i+1);
                path.pop_back();
            }
        }
    }
    vector<string> letterCombinations(string digits) {
        map<char,vector<char>> mp;//定义映射
        mp['2']=vector<char>{'a','b','c'};
        mp['3']=vector<char>{'d','e','f'};
        mp['4']=vector<char>{'g','h','i'};
        mp['5']=vector<char>{'j','k','l'};
        mp['6']=vector<char>{'m','n','o'};
        mp['7']=vector<char>{'p','q','r','s'};
        mp['8']=vector<char>{'t','u','v'};
        mp['9']=vector<char>{'w','x','y','z'};
        backtracking(mp,digits,0);//从0开始
        return ans;
    }
};

标答使用一个二维数组用来标识，比我们使用map占用空间更小。看标答还发现我们的代码外层for循环可以去掉，因为本题对digits中的所有数字都要取到对应的字母，和之前的组合问题不同。
优化后代码：

class Solution {
public:
    vector<string> ans;
    string path;
    void backtracking(map<char,vector<char>> &mp,string digits,int begin){
        if(digits.empty()){//没有选择，直接返回
            return;
        }
        if(path.size()==digits.size()){
            ans.push_back(path);
            return;
        }
        for(char c:mp[digits[begin]]){//还要对第一个数字对应的字母依次遍历
            path.push_back(c);
            backtracking(mp,digits,begin+1);
            path.pop_back();
        }
    }
    vector<string> letterCombinations(string digits) {
        map<char,vector<char>> mp;//定义映射
        mp['2']=vector<char>{'a','b','c'};
        mp['3']=vector<char>{'d','e','f'};
        mp['4']=vector<char>{'g','h','i'};
        mp['5']=vector<char>{'j','k','l'};
        mp['6']=vector<char>{'m','n','o'};
        mp['7']=vector<char>{'p','q','r','s'};
        mp['8']=vector<char>{'t','u','v'};
        mp['9']=vector<char>{'w','x','y','z'};
        backtracking(mp,digits,0);//从0开始
        return ans;
    }
};

标答：

class Solution {
private:
    const string letterMap[10] = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
    };
public:
    vector<string> result;
    string s;
    void backtracking(const string& digits, int index) {
        if (index == digits.size()) {
            result.push_back(s);
            return;
        }
        int digit = digits[index] - '0';        // 将index指向的数字转为int
        string letters = letterMap[digit];      // 取数字对应的字符集
        for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);            // 处理
            backtracking(digits, index + 1);    // 递归，注意index+1，一下层要处理下一个数字了
            s.pop_back();                       // 回溯
        }
    }
    vector<string> letterCombinations(string digits) {
        s.clear();
        result.clear();
        if (digits.size() == 0) {
            return result;
        }
        backtracking(digits, 0);
        return result;
    }
};