代码随想录第二十五天 | 回溯：一个集合内的组合及剪枝（leetcode 216），两个集合间的组合（leetcode 17）

Asher Gu

已于 2024-04-12 12:14:50 修改

阅读量32

点赞数 1

分类专栏： leetcode c++ 文章标签：剪枝 leetcode 算法 c++ 数据结构

于 2023-10-11 15:23:00 首次发布

本文链接：https://blog.csdn.net/AsherGu/article/details/133770171

版权

leetcode c++ 专栏收录该内容

52 篇文章 1 订阅

订阅专栏

1、一个集合内的组合问题

1.1 leetcode 216：组合总和

这里curNum相当于横向递归的起点位置，一般回溯需要在回溯函数的参数中记录一下下一次递归的起点或者提示信息
第一遍代码

class Solution {
public:
    vector<vector<int>> res;
    void backTracking(int k, int n, int curSum, int curNum, vector<int>& tmp) {
        //这里curNum相当于横向递归的起点位置，一般回溯需要记录一下当前的起点
        if(tmp.size() == k) {
            if(curSum == n) {
                res.push_back(tmp);
            }
            return;
        }
        for(int i = curNum; i <= n; i++) {
            //注意这里i是到n（或者9）不是到k,检查的时候可能这里写错了
            tmp.push_back(i);
            backTracking(k, n, curSum+i, i+1, tmp);
            //下一层递归就是从后一个元素开始了
            tmp.pop_back();
        }
        return;
    }

    vector<vector<int>> combinationSum3(int k, int n) {
        vector<int> tmp;
        backTracking(k, n, 0, 1, tmp);
        return res;
    }
};

思路
本题就是在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合
相对于leetcode 77，无非就是多了一个对备选集合的限制，本题是要找到和为n的k个数的组合，而整个集合已经是固定的了[1,…,9]

本题k相当于树的深度，9（因为整个集合就是9个数）就是树的宽度
例如 k = 2，n = 4的话，就是在集合[1,2,3,4,5,6,7,8,9]中求 k（个数） = 2, n（和） = 4的组合
选取过程如图：
一个集合内的组合思路
回溯三部曲
1、确定递归函数参数
和leetcode 77一样，依然需要一维数组path来存放符合条件的结果，二维数组result来存放结果集
这里依然定义path 和 result为全局变量
至于为什么取名为path？从上面树形结构中，可以看出，结果其实就是一条根节点到叶子节点的路径

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

接下来还需要如下参数：
targetSum（int）目标和，也就是题目中的n
k（int）就是题目中要求k个数的集合
sum（int）为已经收集的元素的总和，也就是path里元素的总和
startIndex（int）为下一层for循环搜索的起始位置（单一集合选取组合必备）

所以代码如下：

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

其实这里sum这个参数也可以省略，每次targetSum减去选取的元素数值，然后判断如果targetSum为0了，说明收集到符合条件的结果了，我这里为了直观便于理解，还是加一个sum参数

2、确定终止条件
在上面已经说了，k其实就已经限制树的深度，因为就取k个元素，树再往下深了没有意义
所以如果path.size() 和 k相等了，就终止

如果此时path里收集到的元素和（sum）和targetSum（就是题目描述的n）相同了，就用result收集当前的结果
所以终止代码如下：

if (path.size() == k) {
    if (sum == targetSum) result.push_back(path);
    return; // 如果path.size() == k 但sum != targetSum 直接返回
}

3、单层搜索过程
本题和leetcode 77区别之一就是集合固定的就是9个数[1,…,9]，所以for循环固定i<=9

处理过程就是 path收集每次选取的元素，相当于树型结构里的边，sum来统计path里元素的总和
代码如下：

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

处理过程 和 回溯过程是一一对应的，处理有加，回溯就要有减
代码随想录整体代码如下

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

1.2 leetcode 216：剪枝

一个集合内的组合的剪枝
已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉
那么剪枝的地方可以放在递归函数开始的地方，剪枝代码如下：

if (sum > targetSum) { // 剪枝操作
    return;
}

当然这个剪枝也可以放在 调用递归之前，只不过要记得要把回溯操作给做了

for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) { // 剪枝
    sum += i; // 处理
    path.push_back(i); // 处理
    if (sum > targetSum) { // 剪枝操作
        sum -= i; // 剪枝之前先把回溯做了
        path.pop_back(); // 剪枝之前先把回溯做了
        return;
    }
    backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
    sum -= i; // 回溯
    path.pop_back(); // 回溯
}

自己实现代码

for (int i = startIndex; i <= 9 - k + 1; i++) 
// 从1开始，k = 0 时进不了这个循环（这个是找下一个的），k=9时第一个数要存在1，注意i <= 9 - k + 1

完整代码

class Solution {
private:
    vector<vector<int>> res;
    void backTracking(vector<int>& path, int target, int k, int startIndex) {
        if (target < 0)
            return;
        if (k == 0) {
            if (target == 0) {
                res.push_back(path);
            }
            return;
        }
        for (int i = startIndex; i <= 9 - k + 1; i++) { // 从1开始，k = 0时进不了这个循环，k=9时第一个数要存在1
            path.push_back(i);
            backTracking(path, target - i, k - 1, i + 1);
            path.pop_back();
        }
        return;
    }
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        vector<int> path;
        backTracking(path, n, k, 1);
        return res;
    }
};

2、两个集合间的组合

2.1 leetcode 17：电话号码的字母组合

第一遍代码
所有的digits（string）都从前面进行增删
单独处理一个键有四个数的情况及其后序特殊情况，数的个数为递归深度，键上的字母数为递归宽度（与后面代码随想录代码一致）
digits.insert(0, 1, cur);从string开头插入
digits.erase(0, 1);从string开头删除
当输入为空时需要输出为[], 而非[“”]，所以要单独处理
没有做异常处理

class Solution {
public:
    vector<string> res;
    string s1 = "abcdefghijklmnopqrstuvwxyz";
    //所有的digits都从前面进行增删
    void backTracking(string& digits, string& path) {
        if(digits.size() == 0) {
            res.push_back(path);
            return;
        }
        char cur = digits[0];
        int curNum = cur - '0';
        if(cur == '7') {//处理一个键有四个数的情况及其后序特殊情况
            for(int i = (curNum - 2)*3; i < (curNum - 2)*3+4; i++) {
                path += s1[i];
                digits.erase(0, 1);//从string开头删除
                backTracking(digits, path);
                path.pop_back();
                digits.insert(0, 1, cur);//从string开头插入
            }
        }
        else if(cur == '8') {
            for(int i = 19; i < 22; i++) {
                path += s1[i];
                digits.erase(0, 1);//从string开头删除
                backTracking(digits, path);
                path.pop_back();
                digits.insert(0, 1, cur);//从string开头插入
            }
        }
        else if(cur == '9') {
            for(int i = 22; i < 26; i++) {
                path += s1[i];
                digits.erase(0, 1);//从string开头删除
                backTracking(digits, path);
                path.pop_back();
                digits.insert(0, 1, cur);//从string开头插入
            }
        }
        else{
            for(int i = (curNum - 2)*3; i < (curNum - 2)*3+3; i++) {
                path += s1[i];
                digits.erase(0, 1);
                backTracking(digits, path);
                path.pop_back();
                digits.insert(0, 1, cur);
            }
        }
        return;
    }
    vector<string> letterCombinations(string digits) {
        //当输入为空时需要输出为[], 而非[""]，所以要单独处理
        if(digits.size() == 0) return res;
        string path;
        backTracking(digits, path);
        return res;
    }
};

从示例上来说，输入"23"，最直接的想法就是两层for循环遍历了吧，正好把组合的情况都输出了
如果输入"233"呢，那么就三层for循环，如果"2333"呢，就四层for循环…
和leetcode 77遇到的一样的问题，就是这for循环的层数如何写出来，此时又是回溯法登场的时候了

理解本题后，要解决如下三个问题：
1、数字和字母如何映射（与第一遍代码不同的地方）
2、两个字母就两个for循环，三个字符我就三个for循环，以此类推，然后发现代码根本写不出来
3、输入1 * #按键等等异常情况

1、数字和字母如何映射
可以使用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
};

2、回溯法来解决n个for循环的问题
例如：输入：“23”，抽象为树形结构，如图所示：
回溯法解决n个for循环
图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]

回溯三部曲：
1、确定回溯函数参数
首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量依然定义为全局变量
再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index

注意这个index可不是在一个集合内组合leetcode 77和leetcode 216中的startIndex了
这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度

代码如下：

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

2、确定终止条件
例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集
那么终止条件就是如果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();                       // 回溯
}

注意这里for循环，可不像是在leetcode 77和leetcode 216中从startIndex开始遍历的
因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而leetcode 77和leetcode 216都是求同一个集合内的组合

注意：输入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();                       // 回溯，对字符串操作 push_back/pop_back 字符串只有加号没有减号
        }
    }
    vector<string> letterCombinations(string digits) {
        s.clear();
        result.clear();
        if (digits.size() == 0) { // 空的需要特殊处理，不然不是空的，塞了一个空字符串s进去
            return result;
        }
        backtracking(digits, 0);
        return result;
    }
};

时间复杂度: O(3^m * 4ⁿ)，其中 m 是对应四个字母的数字个数，n 是对应三个字母的数字个数
空间复杂度: O(3^m * 4ⁿ)
一些写法，是把回溯的过程放在递归函数的参数里了，例如如下代码，可以写成这样：（注意注释中不一样的地方）

// 版本二
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;
    }
};