【Leetcode组合一】77. 组合(同一集合，元素不可重复) 216. 组合总和 III(同一集合，元素不可重复) 17. 电话号码的字母组合(不同集合，元素不可重复)

已于 2022-01-20 14:44:37 修改
阅读量578 收藏 1
点赞数 2
分类专栏： # 回溯算法 文章标签： leetcode 回溯
于 2021-09-11 16:51:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46514118/article/details/120239364
版权
本文详细分析了回溯算法在LeetCode中解题的应用，包括LeetCode77、216和17题的解法。通过普通回溯和剪枝回溯两种策略，展示了如何在不同问题背景下实现解题。解法一为标准的回溯流程，解法二则加入了剪枝优化，提高效率。此外，针对LeetCode17题，特别指出其与前两题的不同之处，如无需考虑起始位置和数字映射，并给出了显式和隐式回溯两种实现方式。
摘要由CSDN通过智能技术生成

文章目录



Leetcode77

1.问题描述

在这里插入图片描述

2.解决方案


解法一：普通回溯

包含回溯三部曲，回溯模板等等要点，很重要！，俺的博客和代码sxl都说的很清楚就不多说了

class Solution {
public:
    vector<vector<int> > ans;
    vector<int> path;
    void backtracking(int n,int k,int startIndex){
        if(path.size()==k){
            ans.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 ans;
    }
};


解法二：剪枝回溯

和普通回溯就差了一个for的遍历条件，剪枝俺的博客和代码sxl都说的很清楚就不多说了

for(int i=startIndex;i<=n-(k-path.size())+1;i++)



class Solution1 {
public:
    vector<vector<int> > ans;
    vector<int> path;
    void backtracking(int n,int k,int startIndex){
        if(path.size()==k){
            ans.push_back(path);
            return;
        }
        for(int i=startIndex;i<=n-(k-path.size())+1;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 ans;
    }
};


Leetcode216

1.问题描述

在这里插入图片描述

2.解决方案

首先分析本题和上一题77的区别

1.就是不仅要求k个数，还要求和为n，那说白了不就是加了一个和为n的条件嘛
2.当然随之而来，需要多两个参数，sum你需要记录目前为止path里的节点的和以便终止条件判断，n也就是targetsum目标和
3.其他的几乎一模一样还是回溯三部曲，回溯模板等步骤

void backtracking(int k,int n,int startIndex,int sum)

在这里插入图片描述

解法一：普通回溯

代码sxl有详细过程这就不多说了，就正常步骤，分析清楚和77的区别就好

class Solution {
public:
    vector<vector<int> > ans;
    vector<int> path;
    void backtracking(int k,int n,int startIndex,int sum){
        if(path.size()==k){
            if(sum==n) ans.push_back(path);
            return;
        }

        for(int i=startIndex;i<=9;i++){
            sum+=i;
            path.push_back(i);
            backtracking(k,n,i+1,sum);
            sum-=i;
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(k,n,1,0);
        return ans;
    }
};


解法二：剪枝回溯

剪枝一：

if(sum>n) return;

剪枝二：

for(int i=startIndex;i<=9-(k-path.size())+1;i++)



class Solution1 {
public:
    vector<vector<int> > ans;
    vector<int> path;
    void backtracking(int k,int n,int startIndex,int sum){
        if(sum>n) return;
        if(path.size()==k){
            if(sum==n) ans.push_back(path);
            return;
        }

        for(int i=startIndex;i<=9-(k-path.size())+1;i++){
            sum+=i;
            path.push_back(i);
            backtracking(k,n,i+1,sum);
            sum-=i;
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(k,n,1,0);
        return ans;
    }
};


Leetcode17

1.问题描述

在这里插入图片描述

2.解决方案

在这里插入图片描述

解法一：显示回溯

a.对比17和77，216

这个题和上面两个题77，216都有所不同，上面两个题都是在遍历同一集合，所以在递归参数中出现startindex这个参数，也就是用来标记这一层从集合中的哪开始取数，而一开始我也准备加入这个参数，后来发现加了这个参数好像递归的时候根本不变这个参数的值，所以就删掉了，由于17是不同集合，所以没到新的一层都是从0开始遍历，所以也不需要什么startIndex来标记了！

void backtracking(string digits,int digitsIndex,int traverseStringIndex)
void backtracking(string digits,int digitsIndex)

b.string居然也能push_back()和pop_back()

c.两种终止条件都符合逻辑

if(path.size()==digits.size()){
    ans.push_back(path);
    return;
}
//if(digitsIndex==digits.size()){
//    ans.push_back(path);
//    return;
//}

d.数字和字母映射这个注意

const string letterMap[10]={
        "", //0
        "", //1
        "abc",
        "def",
        "ghi",
        "jkl",
        "mno",
        "pqrs",
        "tuv",
        "wxyz", //9
};

e.其他的就是常规回溯操作没什么区别和上面的题目


class Solution {
public:
    const string letterMap[10]={
            "", //0
            "", //1
            "abc",
            "def",
            "ghi",
            "jkl",
            "mno",
            "pqrs",
            "tuv",
            "wxyz", //9
    };
    string path;
    vector<string> ans;
    void backtracking(string digits,int digitsIndex,int traverseStringIndex){
        if(path.size()==digits.size()){
            ans.push_back(path);
            return;
        }
        //if(digitsIndex==digits.size()){
        //    ans.push_back(path);
        //    return;
        //}
        string traverseString=letterMap[digits[digitsIndex]-48];
        for(int i=traverseStringIndex;i<traverseString.size();i++){
            path=path+traverseString[i];
            backtracking(digits,digitsIndex+1,traverseStringIndex);
            path.pop_back();
        }
    }
    vector<string> letterCombinations(string digits) {
        if(digits.size()==0) return ans;
        backtracking(digits,0,0);
        return ans;
    }
};

class Solution1 {
public:
    const string letterMap[10]={
            "", //0
            "", //1
            "abc",
            "def",
            "ghi",
            "jkl",
            "mno",
            "pqrs",
            "tuv",
            "wxyz", //9
    };
    string path;
    vector<string> ans;
    void backtracking(string digits,int digitsIndex){
        if(path.size()==digits.size()){
            ans.push_back(path);
            return;
        }
        //if(digitsIndex==digits.size()){
        //    ans.push_back(path);
        //    return;
        //}
        string traverseString=letterMap[digits[digitsIndex]-48];
        for(int i=0;i<traverseString.size();i++){
            path.push_back(traverseString[i]);
            backtracking(digits,digitsIndex+1);
            path.pop_back();
        }
    }
    vector<string> letterCombinations(string digits) {
        if(digits.size()==0) return ans;
        backtracking(digits,0);
        return ans;
    }
};


解法二：隐式回溯

表面上看好像把path当作参数，这没有进行回溯操作一样，其实不然，递归中传入的是path+traverseString[i]，那么下一层递归函数中path改变了，然后这一层中其实path根本没变也就是说执行完backtracking(digits,digitsIndex+1,path+traverseString[i]); path根本就没变可以直接执行下一个for，所以也没有回溯这一说，但是可读性差！

for(int i=0;i<traverseString.size();i++){
	//path.push_back(traverseString[i]);
	backtracking(digits,digitsIndex+1,path+traverseString[i]);
	//path.pop_back();
}



class Solution2 {
public:
    const string letterMap[10]={
            "", //0
            "", //1
            "abc",
            "def",
            "ghi",
            "jkl",
            "mno",
            "pqrs",
            "tuv",
            "wxyz", //9
    };
    //vector<char> path;
    //string path;
    vector<string> ans;
    void backtracking(string digits,int digitsIndex,string path){
        if(path.size()==digits.size()){
            ans.push_back(path);
            return;
        }
        //if(digitsIndex==digits.size()){
        //    ans.push_back(path);
        //    return;
        //}
        string traverseString=letterMap[digits[digitsIndex]-48];
        for(int i=0;i<traverseString.size();i++){
            //path.push_back(traverseString[i]);
            backtracking(digits,digitsIndex+1,path+traverseString[i]);
            //path.pop_back();
        }
    }
    vector<string> letterCombinations(string digits) {
        if(digits.size()==0) return ans;
        backtracking(digits,0,"");
        return ans;
    }
};
alone_yue
关注
专栏目录
概率算法 -- 从集合中选取N个不重复的元素
纯，属虚构
04-15 7499
这个问题见了很多，一般表述是，1到n的整数中随机选k个这k个不能重复。变一下即可以是n个元素选k个，不能重复。       有不同复杂度的算法。第一个是笨办法： （1）随机选一个数，然后判断这个数字是否已经被选过了（是否重复），不过不重复，那就就选他了，如果重复，就再随机选一个。 空间复杂度：O(1) 时间复杂度：O(k^2) 而且有一个问题，如果是100个选90个，那么最后冲突的概率
算法训练Day27 | LeetCode39. 组合总和 （元素可重复，数组长度不限）；40. 组合总和III(去重）；131.分割回文串
最新发布
weixin_47284299的博客
11-23 792
算法训练Day27 | LeetCode39. 组合总和 （元素可重复，数组长度不限）；40. 组合总和III(去重）；131.分割回文串
leetcode77,216,17(组合不可重复）39(可重复)40(同层不可重复，树枝可重复)
yys130826的博客
06-19 76
class Solution: def combine(self, n: int, k: int) -> List[List[int]]: res=[] path=[] def backtrack(n,k,start): if len(path)==k: res.append(path[:]) return#返回到刚刚backtrack这一步，然后回溯。 .
无重复字符串的排列组合(leetcode)
浮云
05-23 325
无重复字符串的排列组合，编写一种方法，计算某字符串的所有排列组合，字符串每个字符均不相同。 回溯 代码如下： class Solution: def permution(self,s): if s == "": return [] res = [] path = "" def backtrack(s,path,res): if s == "": return res.append(path) for i in range(len(s)): cur = .
LeetCode40：求数组中所有的不重复组合
Jiangtagong的博客
11-25 869
/* 题目描述: 给定一个数组candidates和一个目标数target，找出candidates中所有可以使 数字和为target的组合.candidate中的每个数字在每个组合中只能使用一次. 注意:所有数字（包括目标数字）都是正整数.解集不能包含重复的组合. 示例 1: Input:candidates=[10,1,2,7,6,1,5],target=8 Output:[[1,7],[1,2,5],[2,6],[1,1,6]] 示例 2: Input:candidates=[2,5,2,1,.
java list 合并 重复的数据_java 实现多个list 合并成一个去掉重复的案例
weixin_39827905的博客
02-12 1181
我就废话不多说了，大家还是直接看代码吧~public static void main(String[] args){List list1 = new ArrayList();list1.add(1);list1.add(2);list1.add(3);list1.add(4);List list2 = new ArrayList();list2.add(1);list2.add(4);list2...
力扣记录：回溯算法1组合——77 组合，17 电话号码的字母组合，216 组合总和III，39 组合总和，40 组合总和II
Kiwi_fruit的博客
05-17 295
力扣记录：回溯算法1组合——77 组合，17 电话号码的字母组合，216 组合总和III，39 组合总和，40 组合总和II
使用 golang 解决回溯算法中的一系列组合问题
weixin_51155231的博客
05-03 470
组合总和 golang 版本 AC 代码
leetcode——"树"题目集合
盛夏与微风
04-16 628
96.不同的二叉搜索树 题目： 给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？ 示例: 输入: 3 输出: 5 解释: 给定 n = 3, 一共有 5 种不同结构的二叉搜索树: 1 3 3 2 1 \ / / / \ \ 3 2 1 1 ...
leetcode
qq_22081299的博客
07-08 623
数组&字符串 9 回文数 26 从排序数组中删除重复项 27 移除元素 #80 从排序数组中删除重复项II #旋转数组 存在重复元素 136 只出现一次的数字 位运算 137 只出现一次的数字II 260 只出现一次的数字III 多个出现一次 两个数组的交集 II 加一 移动零 有效的数独 #旋转图像 反转字符串 #反转整数 #字符串中的第一个唯一字符 有效的字母异位词 验证回文字符串 字符串转整数 (atoi) 实现strStr() 数数并说 #最长公共前缀 #1 两数
递归与回溯7：LeetCode40. 组合总和 II(不可重复)
纵横千里 捭阖四方 的专栏
01-18 307
本题与LeetCode39的区别就是这里candidates 中的每个元素在每个组合中只能使用 一次 。但是candidats数组里的元素是可以重复的。有点绕，我们看一下例子： 示例1： 输入: candidates =[10,1,2,7,6,1,5], target =8, 输出: [ [1,1,6], [1,2,5], [1,7], [2,6] ] 题目说candidates是一个数组，里面有两个1，因此输出的结果里可以出现{1,1}的情况。严格来说这里说candidates是一个集合，是不严..
Leetcode笔记（找不重复的组合*）
weixin_44066066的博客
07-26 185
40 - 77 40. 组合总和 II - medium 有多个相同的元素，但要组成没有重复的组合，有两个方法做： 参考39题的做法，用set避免重复组合 参考39题的做法，但可以让同一层的数字不重复 //15.16 //15.28 //set class Solution { vector<vector<int>> ans; unordered_set<string> s; vector<int> tmp; string
leetcode/没有重复元素集合的全排列，全排列
求道问术
09-14 139
/** * 剑指 Offer II 083. 没有重复元素集合的全排列 * 给定一个不含重复数字的整数数组 nums ，返回其 所有可能的全排列 。可以 按任意顺序 返回答案。 */
求从几个集合中各选取一个元素，并组合的算法
一路向前
06-19 3100
初学python，因为需要，就用 python 简单实现了下，各种语言都一样，需要递归。 # A Recursion function 递归函数 def RecursionFunc(arr1,arrList): if (arrList): string = [] for x in arr1: for y in arrList[0]
三、字母组合迭代器（Biweekly15）
qq_34446716的博客
12-16 207
题目描述： 请你设计一个迭代器类，包括以下内容： 一个构造函数，输入参数包括：一个 有序且字符唯一 的字符串 characters（该字符串只包含小写英文字母）和一个数字 combinationLength 。 函数 next() ，按 字典序 返回长度为 combinationLength 的下一个字母组合。 函数 hasNext() ，只有存在长度为 combinationLength 的下一...
组合1.无重复元素
weixin_47040809的博客
04-02 106
利用begin 结束条件为满足条件 就这 class Solution { List<List<Integer>> res =new ArrayList<List<Integer>>(); public List<List<Integer>> combinationSum(int[] candidates, int target) { if(candidates.length==0){
给定一个数组，求数组中所有元素的可能组合（每个元素只出现一次），使其和等于给定数的解决办法
yaoweijq的专栏
10-18 4742
<br />只求一个组合可以采用背包问题的思路，求所有组合的话，背包问题可能就不太适用了。<br />这里面采用暴力搜索＋剪枝，具体是先对给定的数组进行排序，在求解的深度优先搜索过程<br />中，如果出现中间的求和结果大于预先给定的数，那么就不用继续搜索了（因为后面的元素都大于<br />等于当前的元素，不用再往后搜索了）。<br />以前也写过类似的程序，但只是针对具体问题的，<br />这里修改了下，<br />给出一个比较通用的代码：<br />public void find(int total,
组合问题（不含有重复元素）
drawlessonsfrom的博客
10-07 372
文章目录一、初识组合二、组合代码描述1.简单的组合数量问题2.枚举出每一种的组合情况3.使用next_permutation枚举出所有组合结果 一、初识组合 可以参考:https://www.cnblogs.com/fengxunling/p/9687162.html 二、组合代码描述 1.简单的组合数量问题 描述：从n个里面选择m个进行相关组合排序，不考虑m个元素的位置。 代码如下（示例）： #include <bits/stdc++.h> using namespace std; int
【leetcode-回溯】组合总和/全排列/排列序列/字母大小写全排列/优美的排列
码海畅游记录
03-02 580
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。 说明： 所有数字（包括 target）都是正整数。 解集不能包含重复的组合。 示例 1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [ [7], [2,2,3] ] 示例 2： 输入：candidates = [2,3,5], target = 8,
C语言实现leetcode第77题组合总和解析
LeetCode的第77题是一个组合问题，要求实现一个函数，给定两个整数n和k，返回从1到n的所有可能的k个数的组合。这个问题是组合数学中的经典问题，也是计算机科学中的重要问题，常常作为递归与回溯算法的练习题出现。 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值