代码随想录算法训练营第二十五天 | 216.组合总和III，17.电话号码的字母组合

一、参考资料

组合总和III

题目链接/文章讲解：https://programmercarl.com/0216.%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8CIII.html

视频讲解：https://www.bilibili.com/video/BV1wg411873x

电话号码的字母组合

题目链接/文章讲解：https://programmercarl.com/0017.%E7%94%B5%E8%AF%9D%E5%8F%B7%E7%A0%81%E7%9A%84%E5%AD%97%E6%AF%8D%E7%BB%84%E5%90%88.html

视频讲解：https://www.bilibili.com/video/BV1yV4y1V7Ug

二、LeetCode216.组合总和III

https://leetcode.cn/problems/combination-sum-iii/description/

找出所有相加之和为 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，没有有效的组合。
提示:
2 <= k <= 9
1 <= n <= 60 
  1. class Solution {
  2. private:
  3.     vector<int> path;
  4.     vector<vector<int>> res;
  5.  
  6.     void backtracking(int k, int n, int sum, int startIndex) {
  7.         if (sum == n && path.size() == k) {
  8.             res.push_back(path);
  9.             return ;
  10.         }
  11.         for (int i = startIndex; i <= 9; i++) {
  12.             sum += i;
  13.             path.push_back(i);
  14.             backtracking(k, n, sum, i + 1);
  15.             path.pop_back();
  16.             sum -= i;
  17.         }
  18.     }
  19. public:
  20.     vector<vector<int>> combinationSum3(int k, int n) {
  21.         backtracking(k, n, 0, 1);
  22.         return res;
  23.     }
  24. };

剪枝：两个地方，一是当前选中的数值大于目标总和时，直接return发挥；二是当剩余可选数量不足时，循环结束。【这里的startIndex是用来防止元素重复的，组合问题不用考虑顺序】

  1. class Solution {
  2. private:
  3.     vector<int> path;
  4.     vector<vector<int>> res;
  5.     void backtracking(int n, int k, int sum, int startIndex) {
  6.         if (startIndex > n) return ;
  7.         if (sum == n && path.size() == k) {
  8.             res.push_back(path);
  9.             return ;
  10.         }
  11.         for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
  12.             sum += i;
  13.             path.push_back(i);
  14.             backtracking(n, k, sum, i + 1);
  15.             sum -= i;
  16.             path.pop_back();
  17.         }
  18.     }
  19.  
  20. public:
  21.     vector<vector<int>> combinationSum3(int k, int n) {
  22.         backtracking(n, k, 0, 1);
  23.         return res;
  24.     }
  25. };

剪枝如图：

贴一下卡哥带注释版本的代码便于以后理解：

  1. class Solution {
  2. private:
  3.     vector<vector<int>> result; // 存放结果集
  4.     vector<int> path; // 符合条件的结果
  5.     // targetSum：目标和，也就是题目中的n。
  6.     // k：题目中要求k个数的集合。
  7.     // sum：已经收集的元素的总和，也就是path里元素的总和。
  8.     // startIndex：下一层for循环搜索的起始位置。
  9.     void backtracking(int targetSum, int k, int sum, int startIndex) {
  10.         if (path.size() == k) {
  11.             if (sum == targetSum) result.push_back(path);
  12.             return; // 如果path.size() == k 但sum != targetSum 直接返回
  13.         }
  14.         for (int i = startIndex; i <= 9; i++) {
  15.             sum += i; // 处理
  16.             path.push_back(i); // 处理
  17.             backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
  18.             sum -= i; // 回溯
  19.             path.pop_back(); // 回溯
  20.         }
  21.     }
  22.  
  23. public:
  24.     vector<vector<int>> combinationSum3(int k, int n) {
  25.         result.clear(); // 可以不加
  26.         path.clear();   // 可以不加
  27.         backtracking(n, k, 0, 1);
  28.         return result;
  29.     }
  30. };
  31.  
  32. ——————————————————————————————————————————————————————————————————————
  33. class Solution {
  34. private:
  35.     vector<vector<int>> result; // 存放结果集
  36.     vector<int> path; // 符合条件的结果
  37.     void backtracking(int targetSum, int k, int sum, int startIndex) {
  38.         if (sum > targetSum) { // 剪枝操作
  39.             return; // 如果path.size() == k 但sum != targetSum 直接返回
  40.         }
  41.         if (path.size() == k) {
  42.             if (sum == targetSum) result.push_back(path);
  43.             return;
  44.         }
  45.         for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) { // 剪枝
  46.             sum += i; // 处理
  47.             path.push_back(i); // 处理
  48.             backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
  49.             sum -= i; // 回溯
  50.             path.pop_back(); // 回溯
  51.         }
  52.     }
  53.  
  54. public:
  55.     vector<vector<int>> combinationSum3(int k, int n) {
  56.         result.clear(); // 可以不加
  57.         path.clear();   // 可以不加
  58.         backtracking(n, k, 0, 1);
  59.         return result;
  60.     }
  61. };

三、LeetCode17.电话号码的字母组合

https://leetcode.cn/problems/letter-combinations-of-a-phone-number/description/

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：
输入：digits = "23" 输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
示例 2：
输入：digits = "" 输出：[]
示例 3：
输入：digits = "2" 输出：["a","b","c"]
提示：
0 <= digits.length <= 4
digits[i] 是范围 ['2', '9'] 的一个数字。

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

  1. 数字和字母如何映射

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

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

  1. 两个字母就两个for循环，三个字符我就三个for循环，以此类推，然后发现代码根本写不出来

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

问题抽象：

图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。

  1. // 版本一
  2. class Solution {
  3. private:
  4.     const string letterMap[10] = {
  5.         "", // 0
  6.         "", // 1
  7.         "abc", // 2
  8.         "def", // 3
  9.         "ghi", // 4
  10.         "jkl", // 5
  11.         "mno", // 6
  12.         "pqrs", // 7
  13.         "tuv", // 8
  14.         "wxyz", // 9
  15.     };
  16. public:
  17.     vector<string> result;
  18.     string s;
  19.     void backtracking(const string& digits, int index) {
  20.         if (index == digits.size()) {
  21.             result.push_back(s);
  22.             return;
  23.         }
  24.         int digit = digits[index] - '0';        // 将index指向的数字转为int
  25.         string letters = letterMap[digit];      // 取数字对应的字符集
  26.         for (int i = 0; i < letters.size(); i++) {
  27.             s.push_back(letters[i]);            // 处理
  28.             backtracking(digits, index + 1);    // 递归，注意index+1，一下层要处理下一个数字了
  29.             s.pop_back();                       // 回溯
  30.         }
  31.     }
  32.     vector<string> letterCombinations(string digits) {
  33.         s.clear();
  34.         result.clear();
  35.         if (digits.size() == 0) {
  36.             return result;
  37.         }
  38.         backtracking(digits, 0);
  39.         return result;
  40.     }
  41. };

版本二是隐藏回溯的，觉得不太好理解，暂时不写了

我写的：

  1. class Solution {
  2. private:
  3.     // 先用一个数组做映射
  4.     const string letterMap[10] = {
  5.         "",   
  6.         "",   // 1
  7.         "abc", // 2
  8.         "def", // 3
  9.         "ghi", // 4
  10.         "jkl", // 5
  11.         "mno", // 6
  12.         "pqrs", // 7
  13.         "tuv", // 8
  14.         "wxyz", // 9
  15.     };
  16.     
  17. public:
  18.     string s;
  19.     vector<string> res;
  20.     void backtracking(string digits, int index) {
  21.         if (index == digits.size()) {
  22.             res.push_back(s);
  23.             return ;
  24.         }
  25.         int digit = digits[index] - '0';
  26.         string letter = letterMap[digit];
  27.         for (int i = 0; i < letter.size(); i++) {
  28.             s.push_back(letter[i]);
  29.             backtracking(digits, index + 1);
  30.             s.pop_back();
  31.         }
  32.     }
  33.     vector<string> letterCombinations(string digits) {
  34.         if (digits.size() == 0) {
  35.             return res;
  36.         }
  37.         backtracking(digits, 0);
  38.         return res;
  39.     }
  40. };

今日总结：

  1. 能够在下午按时刷完题还真不容易

  1. 今天把昨天没弄明白的剪枝过程通过组合总和3 这个题弄明白了，敬佩卡哥将的很详细

  1. 已经刷完三道中等题了呢，继续加油！

posted @ 2023-02-08 15:08  ZYM-爱吃柚子的程序媛  阅读(200)  评论(0)    收藏  举报