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

leetcode 216.组合总和III

leetcode 17.电话号码的字母组合

leetcode 216.组合总和III

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。说明：

• 所有数字都是正整数。

• 解集不能包含重复的组合。

同样本题无法使用暴力解法（for循环嵌套），因为for循环次数一旦过大，代码将无法书写。

本题的树型结构与leetcode 77.组合相似，同样是for循环进行横向遍历，递归进行纵向遍历

回溯三部曲：

1. 确定递归函数的参数和返回值

定义两个全局变量path和result分别用来存放单次符合条件的结果和最后的结果集。

递归函数参数包括相加之和为k、结果中数的个数n；由于是组合问题，仍然引入一个参数startIndex用于记录每层for循环起始的位置，防止重复取；同时定义一个sum用于记录当前path中的元素之和。

vector<int> path;
vector<vector<int>> result;
void backtracking(int k, int n, int sum, int startIndex)

2. 确定终止条件

如果path中的元素个数等于k并且sum和n的值相等，则说明找到了一个符合条件的结果。

if(path.size() == k){
    if(sum == n)
        result.push_back(path);
    return;
}

3. 确定单层递归的逻辑

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

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

整体代码：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(int n, int k, int sum, int startIndex){
        if(path.size() == k){
            if(sum == n)
                result.push_back(path);
            return;
        }
        for(int i = startIndex; i <= 9; i++){
            sum += i;
            path.push_back(i);
            backtracking(n, k, sum, i + 1);
            sum -= i;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n, k, 0, 1);
        return result;
    }
};

剪枝：

所以加入：

if(sum > n)
    return;

即可。

总体代码如下：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(int n, int k, int sum, int startIndex){
        if(sum > n){
            return;
        }
        if(path.size() == k){
            if(sum == n)
                result.push_back(path);
            return;
        }
        for(int i = startIndex; i <= 9; i++){
            sum += i;
            path.push_back(i);
            backtracking(n, k, sum, i + 1);
            sum -= i;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n, k, 0, 1);
        return result;
    }
};

leetcode 17.电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

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

理解本题后，要解决如下三个问题：

1. 数字和字母如何映射

2. 两个字母就两个for循环，三个字符我就三个for循环，以此类推，然后发现代码根本写不出来

3. 输入1 * #按键等等异常情况

数字和字母映射

使用map的数据结构或者二维数组来实现数字和字母映射。

const string lettermap[10] = {
    "",       // 0
    "",       // 1
    "abc",    // 2
    "def",    // 3
    "ghi",    // 4
    "jkl",    // 5
    "mno",    // 6
    "pqrs",   // 7
    "tuv",    // 8
    "wxyz",   // 9 
}

回溯三部曲：

1. 确定递归函数的参数和返回值

定义一个string型和vector<string>型的全局变量，用于存放单次符合条件的结果和结果集。

递归函数为void型，参数包括传入的字符串digits和index（输入digits的个数，用于记录遍历到哪一层了）。

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

2. 确定终止条件

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

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

代码如下：

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

3. 确定单层递归的逻辑

首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）。

然后for循环来处理这个字符集，代码如下：

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();                       // 回溯
}

整体代码：

class Solution {
private:
    vector<string> result;
    string s;
    const string letterMap[10] = {
        "",     // 0
        "",     // 1
        "abc",  // 2
        "def",  // 3
        "ghi",  // 4
        "jkl",  // 5
        "mno",  // 6
        "pqrs", // 7
        "tuv",  // 8
        "wxyz", // 9
    };
    
    void backtracking(const string& digits, int index){
        if(index == digits.size()){
            result.push_back(s);
            return;
        }
        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();
        }
    }
public:
    vector<string> letterCombinations(string digits) {
        if(digits.size() == 0){
            return result;
        }
        backtracking(digits, 0);
        return result;
    }
};

本题没有剪枝操作。