leetcode 17 学习笔记

17. 电话号码的字母组合

问题描述：传送门

思路

从示例上来说，输入“23”，最直接的想法就是两层for循环遍历了。
如果输入“233”，就是三层for循环。
如果输入“2333”呢，就四层for循环……

其实，仔细去想，本题要解决如下三个问题：
1、数字和字母如何映射
2、两个字母就两个for循环，三个字符就三个for循环，
但这样以此类推会发现代码根本写不出来。
3、如果按错键，异常，如何处理。

数字和字母如何映射

用map，或者定义一个二维数组，例如：
string letterMap[10]，来做映射。
我用二维数组，代码如下：

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

n个for循环的问题

还是老规矩，抽象成树形结构。如下图：

输入“23”,长度为2，那么就会输出[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]。

①确定回溯函数参数

字符串s收集叶子节点的结果，
字符串数组result保存结果。
利用题目给的string digitits、int型的index。

此时index用以记录遍历到第几个数字，即用来遍历digits的（题目中给出数字字符串），同时，index也表示树的深度。

代码如下：

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

②确定终止条件

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

那么终止条件就是，如果index等于输入的数字个数（digits.size）了
（本来index就是用来遍历digits的）。
就收集结果，结束本层递归。
如下：

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

③确定单层遍历逻辑

首先要取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();                       // 回溯
}

这里的for循环，不是在leetcode 77 学习笔记（组合）以及leetcode 216 学习笔记 中提到的从startIndex开始遍历的。
因为本题特殊，每一个数字代表不同的组合，
即求不同集合之间的组合。
前两道leetcode都是求同一个集合中的组合。

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

本题里，测试数据没有，但是面试的时候要提防。

总体代码

按照回溯模板，可写出如下代码：

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;
    }
};

其实，还可以把回溯放在递归函数里。

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;
    void getCombinations(const string& digits, int index, const string& s) { // 注意参数的不同
        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++) {
            getCombinations(digits, index + 1, s + letters[i]);  // 注意这里的不同
        }
    }
    vector<string> letterCombinations(string digits) {
        result.clear();
        if (digits.size() == 0) {
            return result;
        }
        getCombinations(digits, 0, "");
        return result;

    }
};

不建议把回溯藏在递归的参数里，不方便直观理解。