代码随想录第二十三天 回溯算法 77.组合 216.组合总和 17.电话号码的字母组合

回溯算法 

 LeetCode 77 组合

题目描述

思路

• 递归函数的返回值以及参数

在这里要定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合。

代码如下：

vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件结果

从下图中红线部分可以看出，在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，通过在每一次递归中调整startindex的值，在2,3,4中取数。

那么整体代码如下：

vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件单一结果
void backtracking(int n, int k, int startIndex)

• 回溯函数终止条件

path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，此时用result二维数组，把path保存起来，并终止本层递归。

如图红色部分：

所以终止条件代码如下：

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

• 单层搜索的过程

for循环用来横向遍历，递归的过程是纵向遍历。for循环通过横向遍历，分别取1，2，3，4。递归通过改变startindex的值，纵向遍历。

如此我们才遍历完图中的这棵树。

for循环每次从startIndex开始遍历，然后用path保存取到的节点i。

代码如下：

for (int i = startIndex; i <= n; i++) { // 控制树的横向遍历
    path.push_back(i); // 处理节点
    backtracking(n, k, i + 1); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
    path.pop_back(); // 回溯，撤销处理的节点
}

代码实现

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(int n,int k,int startindex){
        if(path.size() == k){
            result.push_back(path);
            return;
        }
        for(int i = startindex;i <= n;i++){
            path.push_back(i);
            backtracking(n,k,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        backtracking(n,k,1);
        return result;
    }
};

 剪枝优化

上一题中，我们需要遍历n的所有取值，但是有些时候我们并不需要把这几个数全部都试一遍，来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。

从77题我们可以知道for循环是进行横向遍历的，所以我们只需要改变横向遍历的范围即可，那将范围更改到什么数值呢，应该更改到startindex到n-(k-path.size())+1，k-path.size()是目前还需要加入组合的数量，如果还需要三个数字加入组合，那么就需要从index为1的数字搜索，也就是n-(k-path.size())+1

LeetCode 216 组合总和

题目描述

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

• 只使用数字1到9
• 每个数字 最多使用一次 

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例 3:

输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

思路

这道题与77题第一个不同的地方在于终止条件，多了一个要判断总和是否与要求的一致，接下来进入for循环，要更新目前的sum的值，在i被存进数组的时候，将i加进sum，去比较总和是否符合条件，比较完之后，再将i从sum中减去。

代码实现

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

LeetCode17 电话号码的字母组合 

题目描述

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

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

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

思路

• 确定回溯函数参数

首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量我依然定义为全局。

本题中的参数除了题目中给的string digits，然后还要有一个参数就是int型的index。这个index代表的不是77题中的startindex，因为这次题目中遍历的是两个集合，所以不需要startindex去调整从哪里开始遍历元素。

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

代码如下：

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

• 确定终止条件

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

那么终止条件就是如果收集结果的字符串s的大小等于输入的数字个数digits.size了。

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

代码如下：

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

• 确定单层遍历逻辑

首先要根据index，转换成需要遍历的字符串，字符串在digits中，通过映射将digits中的数字，转换成我们需要遍历的字符串。还需要注意的点是这里的i是从0开始，而不是从startindex开始，因为遍历两个集合都是从第0个元素。

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