代码随想录算法训练营

216.组合总和III

题目链接:216.组合总和III

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数,并且每种组合中不存在重复的数字。

说明:

  • 所有数字都是正整数。
  • 解集不能包含重复的组合。

总体思路

本题就是在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合

本题k相当于树的深度,9(因为整个集合就是9个数)就是树的宽度。

例如 k = 2,n = 4的话,就是在集合[1,2,3,4,5,6,7,8,9]中求 k(个数) = 2, n(和) = 4的组合。

选取过程如图:

回溯三部曲

  • 确定递归参数

    仍然需要一维数组path存放符合的结果,二维数组result来存放结果集

    结果就是一条根节点到叶子节点的路径。
  1. vector<vector<int>> result;//存放结果集
  2. vector<int> pat;//符合条件的结果

接下来需要如下参数:

  • targetSum (int) 目标和,即题目中的n
  • k (int) 题目中要求k个数的集合
  • sum (int) 为已收集元素的总和,也是path里元素的总和
  • startIndex(int) 为下一层for循环搜索的起始位置

    代码如下:
  1. vector<vector<int>> result;//存放结果集
  2. vector<int> pat;//符合条件的结果
  3. void backtracking(int targetSum,int k, int sum, int startIndex)
  • 确定终止条件

    题目中的k就相当于限制了树的深度,当path.size( )和k相等了,就终止。

    此时path里收集到的元素和sum和targetSum(题目中的n)相同了,就result收集结果

    代码如下:
  1. if(path.size()==k){
  2. if(sum==targetSum) result.push_back(path);
  3. return;//如果path.size()==k但sum!=targetSum 直接返回
  4. }
  • 单层搜索过程



    处理过程就是path收集每次选区的元素,相当于树形结构的边,sum用来统计path的总和
  1. for(int i=startIndex;i<=9;i++){
  2. sum+=1;
  3. path.push_back(i);
  4. backtracking(targetSum,k,sum,i+1);
  5. sum-=1;//回溯
  6. path.pop_back()//回溯
  7. }

总体如下:

  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. public:
  23. vector<vector<int>> combinationSum3(int k, int n) {
  24. result.clear(); // 可以不加
  25. path.clear(); // 可以不加
  26. backtracking(n, k, 0, 1);
  27. return result;
  28. }
  29. };

剪枝



已选元素总和如果已经大于n(图中数值为4)了,那么往后遍历就没有意义了,直接剪掉。

那么剪枝的地方可以放在递归函数开始的地方,剪枝代码如下:

  1. if (sum > targetSum) { // 剪枝操作
  2. return;
  3. }

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

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

回溯算法:组合问题再剪剪枝 一样,for循环的范围也可以剪枝,i <= 9 - (k - path.size()) + 1就可以了。

最后C++代码如下:

  1. class Solution {
  2. private:
  3. vector<vector<int>> result; // 存放结果集
  4. vector<int> path; // 符合条件的结果
  5. void backtracking(int targetSum, int k, int sum, int startIndex) {
  6. if (sum > targetSum) { // 剪枝操作
  7. return; // 如果path.size() == k 但sum != targetSum 直接返回
  8. }
  9. if (path.size() == k) {
  10. if (sum == targetSum) result.push_back(path);
  11. return;
  12. }
  13. for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) { // 剪枝
  14. sum += i; // 处理
  15. path.push_back(i); // 处理
  16. backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
  17. sum -= i; // 回溯
  18. path.pop_back(); // 回溯
  19. }
  20. }
  21. public:
  22. vector<vector<int>> combinationSum3(int k, int n) {
  23. result.clear(); // 可以不加
  24. path.clear(); // 可以不加
  25. backtracking(n, k, 0, 1);
  26. return result;
  27. }
  28. };

17.电话号码的字母组合

题目链接:17.电话号码的字母组合

给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。

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

  • 输入:"23"
  • 输出:["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

总体思路

直观来看就是两层for循环进行输出,三层就是3个for循环

因此仍然使用回溯进行。

首先有三个问题:

  1. 数字和字母如何映射
  2. 两个字母就两个for循环,三个字符我就三个for循环,以此类推,然后发现代码根本写不出来
  3. 输入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. };

回溯法来解决n个for循环的问题

对于回溯法还不了解的同学看这篇:关于回溯算法,你该了解这些!

例如:输入:"23",抽象为树形结构,如图所示:

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

回溯三部曲:
  • 确定回溯函数参数

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

    再来看参数,参数指定是有题目中给的string digits,然后还要有一个参数就是int型的index。

    注意这个index可不是 77.组合216.组合总和III中的startIndex了。

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

    代码如下:
  1. vector<string> result;
  2. string s;
  3. void backtracking(const string& digits, int index)
  • 确定终止条件

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

    那么终止条件就是如果index 等于 输入的数字个数(digits.size)了(本来index就是用来遍历digits的)。

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

    代码如下:
  1. if (index == digits.size()) {
  2. result.push_back(s);
  3. return;
  4. }
  • 确定单层遍历逻辑

    首先要取index指向的数字,并找到对应的字符集(手机键盘的字符集)。

    然后for循环来处理这个字符集,代码如下:
  1. int digit = digits[index] - '0'; // 将index指向的数字转为int
  2. string letters = letterMap[digit]; // 取数字对应的字符集
  3. for (int i = 0; i < letters.size(); i++) {
  4. s.push_back(letters[i]); // 处理
  5. backtracking(digits, index + 1); // 递归,注意index+1,一下层要处理下一个数字了
  6. s.pop_back(); // 回溯
  7. }

注意这里for循环,可不像是在回溯算法:求组合问题!回溯算法:求组合总和!中从startIndex开始遍历的

因为本题每一个数字代表的是不同集合,也就是求不同集合之间的组合,而77. 组合216.组合总和III都是求同一个集合中的组合!

注意:输入1 * # 按键等等异常情况

代码中最好考虑这些异常情况,但题目的测试数据中应该没有异常情况的数据,所以我就没有加了。

但是要知道会有这些异常,如果是现场面试中,一定要考虑到!

代码:

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

代码随想录算法训练营Day24 回溯算法|216.组合总和III 17.电话号码的字母组合的更多相关文章

  1. LeetCode ● 216.组合总和III ● 17.电话号码的字母组合

    LeetCode 216.组合总和III 分析1.0 回溯问题 组合总和sum == n 时以及path中元素个数 == k 时,res.add(new path) 返回后递归删除掉当前值 class ...

  2. Leetcode之回溯法专题-216. 组合总和 III(Combination Sum III)

    Leetcode之回溯法专题-216. 组合总和 III(Combination Sum III) 同类题目: Leetcode之回溯法专题-39. 组合总数(Combination Sum) Lee ...

  3. 216. 组合总和 III

    216. 组合总和 III 题意 找出所有相加之和为 n 的 k 个数的组合.组合中只允许含有 1 - 9 的正整数,并且每种组合中不存在重复的数字. 说明: 所有数字都是正整数. 解集不能包含重复的 ...

  4. Java实现 LeetCode 216. 组合总和 III(三)

    216. 组合总和 III 找出所有相加之和为 n 的 k 个数的组合.组合中只允许含有 1 - 9 的正整数,并且每种组合中不存在重复的数字. 说明: 所有数字都是正整数. 解集不能包含重复的组合. ...

  5. LeetCode 216. 组合总和 III(Combination Sum III)

    题目描述 找出所有相加之和为 n 的 k 个数的组合.组合中只允许含有 1 - 9 的正整数,并且每种组合中不存在重复的数字. 说明: 所有数字都是正整数. 解集不能包含重复的组合. 示例 1: 输入 ...

  6. Leetcode 216. 组合总和 III

    地址 https://leetcode-cn.com/problems/combination-sum-iii/ 找出所有相加之和为 n 的 k 个数的组合.组合中只允许含有 1 - 9 的正整数,并 ...

  7. 216组合总和III

    题目:找出所有相加之和为 n 的 k 个数的组合.组合中只允许含有 1 - 9 的正整数,并且每种组合中不存在重复的数字.说明:所有数字都是正整数.解集不能包含重复的组合. 示例 1:输入: k = ...

  8. 8皇后以及N皇后算法探究,回溯算法的JAVA实现,非递归,循环控制及其优化

    上两篇博客 8皇后以及N皇后算法探究,回溯算法的JAVA实现,递归方案 8皇后以及N皇后算法探究,回溯算法的JAVA实现,非递归,数据结构“栈”实现 研究了递归方法实现回溯,解决N皇后问题,下面我们来 ...

  9. Leetcode之回溯法专题-17. 电话号码的字母组合(Letter Combinations of a Phone Number)

    [Leetcode]17. 电话号码的字母组合(Letter Combinations of a Phone Number) 题目描述: 给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组 ...

  10. 8皇后以及N皇后算法探究,回溯算法的JAVA实现,递归方案

    八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例.该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行.同 ...

随机推荐

  1. Linux & 标准C语言学习 <DAY8_1>

    一.进制转换     1.为什么要使用二进制.八进制.十六进制         因为目前的CPU只能识别高低两种电平,只能对二进制数据进行计算         二进制虽然能够直接被计算机识别,但是不方 ...

  2. springboot格式化timestamp时间

    spring.jackson.date-format=yyyy-MM-dd HH:mm:ss

  3. 跨域解决方案CORS

    这里说的 js 跨域是指通过 js 在不同的域之间进行数据传输或通信,例如通过 ajax 向一个不同的域请求数据,或者通过 js 获取页面中不同域中(iframe)的数据.只要协议.域名.端口有任何一 ...

  4. 1 - Windows 10 - Python 类的常用高级系统函数(方法)通识

    @ 目录 一.系统函数__init__() 初始化类函数 二.系统函数__call__() 调用对象函数 三.系统函数__dict__类属性查询函数 四.系统函数__str__()描述类信息函数 五. ...

  5. C++ 测试框架 GoogleTest 初学者入门篇 甲

    *以下内容为本人的学习笔记,如需要转载,请声明原文链接微信公众号「ENG八戒」https://mp.weixin.qq.com/s/BS_u9A4EY50y4vDDuxkCAQ 开发者虽然主要负责工程 ...

  6. 地图:leaflet基本使用

    leaflet:一个开源并且对移动端友好的交互式地图 JavaScript 库 中文文档:https://leafletjs.cn/reference.html 官网(英文):https://icli ...

  7. Unity3D中的Attribute详解(四)

    本篇我们将逐一讲解Unity中经常使用的Attribute(Unity对应的文档版本为2018.1b). 首先是Serializable,SerializeField以及NonSerialized,H ...

  8. JSTL标签fmt:formatDate格式化日期出错

    现象&背景: 异常: "org.apache.jasper.JasperException: 在 [115] 行处理 [/WEB-INF/jsp/modules/receivedya ...

  9. 搭建DHCP服务,实现自动分配地址

    DHCP实现原理 DHCP定义 DHCP(Dynamic Host Configuration Protocol,动态主机配置协议)是一个局域网的网络协议,使用UDP协议工作.它是一种流行的Clien ...

  10. [软件体系结构/架构]零拷贝技术(Zero-copy)[转发]

    0 前言 近期遇到难题:1个大数据集的查询导出API,因从数据库查询后占用内存极大,每次调用将消耗近100MB的JVM内存资源.故现需考虑研究和应用零拷贝技术. 如下全文摘自: 看一遍就理解:零拷贝原 ...