算法训练 | 回溯算法Part2 | 216.组合总和III、17.电话号码的字母组合

Orion嵌入式随想录

已于 2024-06-09 11:24:15 修改

阅读量796

点赞数 19

分类专栏：数据结构算法训练文章标签：算法

于 2024-06-02 15:55:22 首次发布

本文链接：https://blog.csdn.net/qq_48896570/article/details/139392666

版权

数据结构算法训练专栏收录该内容

52 篇文章 0 订阅

订阅专栏

216.组合总和III

题目链接：216. 组合总和 III - 力扣（LeetCode）
文章讲解：programmercarl.com

回溯法

解题思路
- 本题就是在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合。
- 相对于组合 (opens new window)，多了一个限制，本题是要找到和为n的k个数的组合，而整个集合已经是固定的了[1,...,9]。
- 本题k相当于树的深度，9（因为整个集合就是9个数）就是树的宽度。
- 例如 k = 2，n = 4的话，就是在集合[1,2,3,4,5,6,7,8,9]中求 k（个数） = 2, n（和） = 4的组合。
- 选取过程如图：
解题步骤
- 确定递归函数参数：
  - 依然需要一维数组path来存放符合条件的结果，二维数组result来存放结果集。定义path 和 result为全局变量。取名为path结果其实就是一条根节点到叶子节点的路径。
  - targetSum（int）目标和，也就是题目中的n。
  - k（int）就是题目中要求k个数的集合。
  - sum（int）为已经收集的元素的总和，也就是path里元素的总和。（sum参数也可以省略，每次targetSum减去选取的元素数值，然后判断如果targetSum为0了，说明收集到符合条件的结果了，为了直观便于理解，加一个sum参数。）
  - startIndex（int）为下一层for循环搜索的起始位置。
- 确定终止条件：k其实就已经限制树的深度，因为就取k个元素，树再往下深了没有意义。所以如果path.size() 和 k相等了，就终止。如果此时path里收集到的元素和（sum）和targetSum（就是题目描述的n）相同了，就用result收集当前的结果。
- 单层搜索过程：处理过程就是 path收集每次选取的元素，相当于树型结构里的边，sum来统计path里元素的总和。
代码一：回溯法

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

剪枝优

已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉。那么剪枝的地方可以放在递归函数开始的地方，剪枝代码如下：
剪枝也可以放在调用递归之前，只不过要记得要回溯操作给做了。for循环的范围也可以剪枝，i <= 9 - (k - path.size()) + 1就可以了。
代码一：优化

class Solution {
private:
    vector<vector<int>> result; // 存放结果集
    vector<int> path; // 符合条件的结果
    void backtracking(int targetSum, int k, int sum, int startIndex) {
        if (sum > targetSum) { // 剪枝操作
            return; 
        }
        if (path.size() == k) {
            if (sum == targetSum) result.push_back(path);
            return; // 如果path.size() == k 但sum != targetSum 直接返回
        }
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; 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.电话号码的字母组合

题目链接：leetcode.cn
文章讲解：代码随想录

回溯法

解题思路
- 数字和字母映射：可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射，定义一个二维数组。
- 回溯法来解决n个for循环的问题：输入："23"，抽象为树形结构。遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。
解题步骤
- 确定回溯函数参数：
  - 首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量我依然定义为全局。
  - 参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。注意这个index不是 77.组合 (opens new window)和216.组合总和III (opens new window)中的startIndex了。这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。
- 确定终止条件：如果index 等于输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。然后收集结果，结束本层递归。
- 确定单层遍历逻辑：首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）。然后for循环来处理这个字符集。注意这里for循环，不像是在回溯算法：求组合问题！ (opens new window)和回溯算法：求组合总和！ (opens new window)中从startIndex开始遍历的。因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而77. 组合 (opens newwindow)和216.组合总和III (opens new window)都是求同一个集合中的组合！
代码一：回溯法

// 版本一
// 时间复杂度: O(3^m * 4^n)，其中 m 是对应四个字母的数字个数，n 是对应三个字母的数字个数
// 空间复杂度: O(3^m * 4^n)
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;
    }
};

Orion嵌入式随想录

关注

19
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
算法训练 | 回溯算法Part2 | 216.组合总和III、17.电话号码的字母组合

遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。（sum参数也可以省略，每次targetSum减去选取的元素数值，然后判断如果targetSum为0了，说明收集到符合条件的结果了，为了直观便于理解，加一个sum参数。例如 k = 2，n = 4的话，就是在集合[1,2,3,4,5,6,7,8,9]中求 k（个数） = 2, n（和） = 4的组合。注意这个index不是。
复制链接

扫一扫