回溯算法 ----- 第2天

今日内容：

• 216.组合总和III

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

---

组合总和III

 

 本题k相当于树的深度，9（因为整个集合就是9个数）就是树的宽度。

回溯三部曲

1、确定递归函数参数

vector<vector<int>> result;//最后的结果
vector<int> path;//保存每个可能的结果

void backtracking(int targetSum, int k, int Sum, int startIndex)

targetSum：目标和，题目中的n;

k:题目中的要求

Sum：当前路径的和，path里的元素的和

startIndex：为下一层for循环的起始位置

2、终止条件

if(path.size() == k)
{
    if(Sum == targetSum)
    {
        result.push_back(path);
        return;
    }
}

这个其实很好理解，首先满足k个数，然后再满足这个k个数的和符合n，这样就可以放到result。

回溯搜索的遍历过程

for(int i = startIndex; i <= 9; i++)
{
    sum += i;
    path.push_back(i);
    backtracking(targetSum, k, Sum, i + 1);
    sum -= i;
    path.pop_back(i);
}

所以如下代码

class Solution {
private:
    vector<vector<int>> result; // 存放结果集
    vector<int> path; // 符合条件的结果
    // targetSum：目标和，也就是题目中的n。
    // k：题目中要求k个数的集合。
    // sum：已经收集的元素的总和，也就是path里元素的总和。
    // startIndex：下一层for循环搜索的起始位置。
    void backtracking(int targetSum, int k, int sum, int startIndex) {
        if (path.size() == k) {
            if (sum == targetSum) result.push_back(path);
            return; // 如果path.size() == k 但sum != targetSum 直接返回
        }
        for (int i = startIndex; i <= 9; 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.电话号码的字母组合

 

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

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、确定递归函数的参数 

vector<string> result;
string s;

void backtracking(const string& digits, int index);
//digits为我们想要的字母组合对应的字数 "23"
//index就是上一个题目的startIndex，这个index是记录遍历第几个数字了，
//就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

这个index的理解就是遍历digits这个字符串，当index为digits的大小的时候说明就遍历结束了。

2、确定终止条件

就和上面说的一样

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

3、遍历逻辑

void backtracking(const string& digits, int index)
{
    int digit = digits[index] - '0';//比如digits = '23',index = 0,那么digit = 0开始

    string letters = letterMap[digit];//digits[2]对应的字母"abc"
    for(int i = 0; i < letters.size(); i++)
    {
        s.push_back(letters[i];
        backtracking(digits, index + 1);
        s.pop_back();
    }
}

最后的代码

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