leetcode回溯算法

最新推荐文章于 2023-09-11 00:22:15 发布
最新推荐文章于 2023-09-11 00:22:15 发布
阅读量283 收藏 1
点赞数 1
分类专栏： 刷题算法整理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41169280/article/details/114765872
版权

77：组合问题在这里插入图片描述

使用for循环，同时使用回溯。n相当于数的宽度，k相当于树的深度。for使用广度优先，k遍历深度。一定要理解清楚！index是每一次开始遍历的地方，但是后续主要是i开始加

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void travel(int n,int k,int index){
        if(path.size()==k) {
            result.push_back(path);
            return;
        }
        for(int i=index;i<=n;i++){
            path.push_back(i);
            travel(n,k,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        result.clear();
        path.clear();
        travel(n,k,1);
        return result;
    }
};

剪枝后：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void travel(int n,int k,int index){
        if(path.size()==k) {
            result.push_back(path);
            return;
        }
        for(int i=index;i<=n-(k-path.size())+1;i++){
            path.push_back(i);
            travel(n,k,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        result.clear();
        path.clear();
        travel(n,k,1);
        return result;
    }
};

17：电话号码的组合(再刷一遍)

在这里插入图片描述
使用回溯，一定要想清楚，for是一层的多个情况，本题就是一个数字对应的多个字母，而递归是深度遍历，是输入的字符串对应的每一个数字，输入之后再次遍历下一个

class Solution {
public:
    string path;
    vector<string> result;
    string letter[10]={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    void travel(string digits,int index){
        if(index==digits.size()) {
            result.push_back(path);
            return;
        }
        int digit=digits[index]-'0';
        string letters=letter[digit];
        for(int i=0;i<letters.size();i++){
            path.push_back(letters[i]);
            travel(digits,index+1);
            path.pop_back();
        }

    }
    vector<string> letterCombinations(string digits) {        
        int m=digits.size();
        if(m==0) return result;
        travel(digits,0);
        return result;
    }
};

131：分割回文串

在这里插入图片描述
index到i是要截取的子串,使用回溯,注意！！！！！形参对应！有几个参数检查
substr函数使用方法:

s.substr(开始i,截取长度); 不用使用begin()函数！！！

class Solution {
public:
    vector<vector<string>> result;
    vector<string> path;
    bool ispa(string s,int i,int j){
        if(i-j==0) return true;
        while(i<j){
            if(s[i]!=s[j]) return false;
            i++;
            j--;
        }
        return true;
    }
    void travel(string& s,int index){
        if(index>=s.size()){
            result.push_back(path);
            return;
        }
        for(int i=index;i<s.size();i++){
            if(ispa(s,index,i)){
                path.push_back(s.substr(index,i-index+1));
            }
            else continue;
            travel(s,i+1);
            path.pop_back();
        }
    }
    vector<vector<string>> partition(string s) {
        int m=s.size();
        if(m==0) return result;
        travel(s,0);
        return result;
    }
};

93：复原IP地址

在这里插入图片描述
使用回溯，一定要注意！！！存在@等无效字符，需要判断！！！
对于同一组合，因为不能重复分割，需要使用index
注意！题目要求必须分成四段，因此需要考虑！
使用insert直接插入’.’，之后删除erase
最后’.'后不能字符串为0

class Solution {
public:
    vector<string> result;
    bool isvalid(string s){
        if(s.size()==0) return false;
        int ans=0;
        for(int i=0;i<s.size();i++){
            if(s[i]-'0'>9||s[i]-'0'<0) return false;
            ans=ans*10+(s[i]-'0');
            if(ans>255) return false;
        }
        if(s[0]=='0'&&s.size()>1) return false;    //考虑全面，“00”也不符合
        return true;
    }
    void travel(string &s,int index,int pointnum){
        if(pointnum==3){
            if(isvalid(s.substr(index,s.size()-index))){
                result.push_back(s);
            }
            return;
        }
        for(int i=index;i<s.size();i++){
            if(isvalid(s.substr(index,i-index+1))){
                s.insert(s.begin()+i+1,'.');    
                pointnum++;
                travel(s,i+2,pointnum);   
                pointnum--;
                s.erase(s.begin()+i+1);         
            }
            else break;;
        }
    }
    vector<string> restoreIpAddresses(string s) {
        int m=s.size();
        if(m==0) return result;
        travel(s,0,0);
        return result;
    }
};

78：子集问题

在这里插入图片描述
记录所有节点，剩余集合为空则是叶子节点，可以返回。即index大于数组长度

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void travel(vector<int>& nums,int index){
        result.push_back(path);
        if(index>=nums.size()) return;
        for(int i=index;i<nums.size();i++){
            path.push_back(nums[i]);
            travel(nums,i+1);
            path.pop_back();
        }

    }
    vector<vector<int>> subsets(vector<int>& nums) {
        int m=nums.size();
        if(m==0) return result;
        travel(nums,0);
        return result;
    }
};

90：子集2

在这里插入图片描述
去重需要先对集合排序，把相同的元素放在一起。去重问题，树枝不去重，树层去重，使用used数组

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void travel(vector<int>& nums,int index,vector<bool>& used){
        result.push_back(path);
        if(index>=nums.size()) return;
        for(int i=index;i<nums.size();i++){
            if(i>0&&nums[i]==nums[i-1]&&used[i-1]==false) continue;
            path.push_back(nums[i]);
            used[i]=true;
            travel(nums,i+1,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        int m=nums.size();
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(),false);
        travel(nums,0,used);
        return result;
    }
};

491：递增子序列

在这里插入图片描述
不要加return，因为要取所有节点

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void travel(vector<int> nums,int index){
        if(path.size()>=2){
            result.push_back(path);
        }
        unordered_set<int> uset;
        if(index>=nums.size()) return;
        for(int i=index;i<nums.size();i++){
            if((!path.empty()&&nums[i]<path.back())||uset.find(nums[i])!=uset.end()) continue;
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            travel(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        int m=nums.size();
        if(m==0) return result;
        travel(nums,0);
        return result;
    }
};

46：全排列

在这里插入图片描述
使用use数组，由于是排列问题，因此必须从0开始

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void travel(vector<int>nums,vector<bool>& used){
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(used[i]==false) continue;
            path.push_back(nums[i]);
            used[i]=false;
            travel(nums,used);
            used[i]=true;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        int m=nums.size();
        if(m==0) return result;
        vector<bool> used(nums.size(),true);
        travel(nums,used);
        return result;
    }
};

47：全排列2

在这里插入图片描述
去重一定要先排序，必须使用了才去重
used[i - 1] == false，说明同一树支nums[i - 1]使用过
used[i - 1] ==true，说明同一树层nums[i - 1]使用过

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void travel(vector<int> nums,vector<bool>& used){
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(used[i]==false||(i>0&&used[i-1]==false&&nums[i]==nums[i-1])) continue;
            path.push_back(nums[i]);
            used[i]=false;
            travel(nums,used);
            used[i]=true;
            path.pop_back();
        }

    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        int m=nums.size();
        if(m==0) return result;
        vector<bool> used(nums.size(),true);
        sort(nums.begin(),nums.end());
        travel(nums,used);
        return result;
    }
};
crasyter
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode初级算法.zip
10-23
《LeetCode初级算法C++详解》 LeetCode作为全球知名的在线编程挑战平台，深受程序员喜爱，尤其是对于初学者，它提供了丰富的算法题目，是提升编程技能和算法理解的绝佳场所。本资料集“leetcode初级算法.zip”正是...
LeetCode算法之----回溯
程序大视界
01-07 924
回溯算法
Leetcode学习之回溯算法
frighting_ing的博客
11-14 4469
1. 回溯算法理论基础 什么是回溯法 回溯法也可以叫做回溯搜索法，它是一种搜索的方式。 在二叉树系列中，我们已经不止一次，提到了回溯，例如二叉树：以为使用了递归，其实还隐藏着回溯。 回溯是递归的副产品，只要有递归就会有回溯。 所以回溯函数也就是递归函数，指的都是一个函数。 回溯法的效率 回溯法的性能如何呢，必须强调的是，虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。 **因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，**如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回
【LeetCode】-回溯算法
银尘博客
03-22 2251
文章目录前言一、组合 前言 初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。 一、组合 题目： 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3],
LeetCode之回溯算法
ji_meng的博客
05-09 719
（如果要问为什么还需要startIndex，因为这还是组合问题啊，也就是不能走回头路，比如[1,2,3]，目标和是4，你可以选[1,1,2]，如果没有startIndex，当你到2的时候，又会有[2,1,1]的可能！首先需要建立一个映射，从字符2-9映射到字母，可以hash可以数组。输入：nums = [1,2,2] 输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
Leetcode回溯法
baidu_41553551的博客
04-03 744
回溯法是复杂度很高的暴力搜索算法，实现简单且有固定模板，常被用于搜索排列组合问题的所有可行解。不同于普通的暴力搜索，回溯法会在每一步判断状态是否合法，而不是等到状态全部生成后再进行确认。当某一步状态非法时，它将回退到上一步中正确的位置，然后继续搜索。前进和后退是回溯法关键的动作。 回溯的本质就是暴力枚举所有可能。要注意的是，由于回溯通常结果集都记录在回溯树的路径上，因此如果不进行撤销操作， 则可能在回溯后状态不正确导致结果有差异， 因此需要在递归到底部往上冒泡的时候进行撤销状态。 如果你每次递归的过
leetcode常用算法java代码
06-02
在编程领域，LeetCode是一个非常受欢迎的在线平台，它提供了大量的编程题目，旨在帮助开发者提升算法能力和解决问题的技巧。这个名为“leetcode常用算法java代码”的压缩包文件很可能包含了使用Java语言实现的...
LeetCode 算法
09-07
LeetCode 是一个在线平台，专注于提供算法练习和面试准备，帮助开发者提升编程技能。这个压缩包文件中的资源可能包括了LeetCode上的各种算法问题的详细解答、思路分析以及可能的代码实现，涵盖多种编程语言，如Java...
leetcode:算法
03-26
在LeetCode上，很多算法问题都可以用Java来解决，例如排序（快速排序、归并排序、堆排序等）、搜索（二分查找、深度优先搜索、广度优先搜索等）、动态规划、图论、回溯法等。通过解决这些题目，Java程序员可以加深对...
leetcode：算法
02-09
2. **算法设计**：包括分治法、动态规划、回溯、贪心算法、二分查找、滑动窗口等，这些基本的算法思想会在很多题目中体现。 3. **TypeScript 特性**：如接口（Interfaces）、类（Classes）、泛型（Generics）、枚举...
LeetCode题解之回溯算法
wenxingxingxing的博客
06-08 394
回溯算法回溯算法要点组合问题77. 组合216. 组合总和 III39. 组合总和40. 组合总和 II 回溯算法要点 回溯法，⼀般可以解决如下⼏种问题： 组合问题： N个数⾥⾯按⼀定规则找出k个数的集合 切割问题：⼀个字符串按⼀定规则有⼏种切割⽅式 ⼦集问题：⼀个N个数的集合⾥有多少符合条件的⼦集 排列问题： N个数按⼀定规则全排列，有⼏种排列⽅式 棋盘问题： N皇后，解数独等等 回溯模板三部曲： 1. 回溯函数模板返回值以及参数，返回值一般为void 2. 回溯函数终止条件 3. 回溯搜索的遍历过程 回
图解 LeetCode 算法汇总——回溯
最新发布
qq_42700121的博客
09-11 781
回溯算法尝试在问题的解空间中搜索可能的解，并在搜索过程中进行选择、撤销选择和终止搜索，直到找到解或确定无解为止。通常通过递归函数来实现回溯算法。在每一步，需要做出选择（选择一个分支）然后递归地探索该选择的结果。在递归返回后，需要撤销之前的选择，以便继续探索其他分支。使用条件语句或循环来控制选择的范围和条件。
回溯算法小结（leetcode回溯题集合）
qq_36309684的博客
10-24 470
回溯算法小结 回溯法定义 回溯法：采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况： 找到一个可能存在的正确的答案； 在尝试了所有可能的分步方法后宣告该问题没有答案。 上面说到回溯法在试错的过程中，会取消上一步或者几步的操作，从而开始进行其它的尝试。这时候的这个过程，
LeetCode回溯算法
xylitolz的博客
03-05 483
文章目录回溯算法 vs 深度优先遍历回溯算法 vs 动态规划共同点不同点LeetCode 22. 括号生成题目回溯LeetCode 39. 组合总和题目回溯LeetCode 46. 全排列题目回溯Reference 回溯算法 vs 深度优先遍历 维基百科中「回溯算法」和「深度优先遍历」的定义: 回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题
LeetCode刷题笔记（回溯算法篇）
m0_47113287的博客
04-20 1003
1.什么是回溯算法，解决什么问题。 因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案。 回溯法，一般可以解决如下几种问题： 组合问题：N个数里面按一定规则找出k个数的集合 切割问题：一个字符串按一定规则有几种切割方式 子集问题：一个N个数的集合里有多少符合条件的子集 排列问题：N个数按一定规则全排列，有几种排列方式 棋盘问题：N皇后，解数独等等 回溯法解决的问题都可以抽象为树形结构，类似图的遍历。 回溯算法的框架如下：方法用来递归，for用来遍历这一层。 vo...
LeetCode 回溯法
abyss_miracle的博客
09-21 315
LeetCode78.子集全排列 大意：给一个数组如[1,2,3]，求出全部的排列情况： { [], [1], [1,2], [1,2,3], [1,3], [2], [2,3] [3] } 有两种回溯思路来做： 1.双递归：（转自力扣，笨猪爆破组） 单看每个元素，都有两种选择：选入子集中，或不选入子集中。 比如[1,2,3]，先考察 1，选或不选，不管选没选 1，都再考察 2，选或不选，以此类推。 画出递归树如下（解的空间树）： 一个子树是一个递归调用，考察当前枚举的数，选它，是一个分支，不选它，又是一
算法设计与分析-回溯法思想的应用(头歌实验)
qq_62524881的博客
04-19 4885
算法设计与分析—头歌实验
LeetCode——回溯
weixin_47156261的博客
03-17 658
组合三部曲 确定函数参数和递归终止条件 for循环遍历树的深度和宽度 回溯记得pop_back. 1. 组合 为了简单将两个vector设为全局变量 startindex要传入，不然递归时无法往下更新 递归过程中伴随回溯，path.pop_back就是在回溯过程中使用的， class Solution { public: vector<vector<int>>res; vector<int>path; void backtracking(int n,int
Leetcode--------回溯法
qq_40128284的博客
08-05 253
回溯法模板： 回溯三部曲： 回溯函数模板返回值以及参数，习惯是函数起名字为backtracking 回溯函数终止条件 if (终止条件) { 存放结果; return; } 回溯搜索的遍历过程 总结： void backtracking(参数) { if (终止条件) { 存放结果; return; } for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) { 处理节点;
leetcode 回溯
08-22
在LeetCode上，有许多使用回溯算法的题目。 回溯算法的基本思想是通过深度优先搜索，不断地尝试下一个可能的解，如果当前解不符合要求，则回退到上一个状态，继续尝试其他可能的解。这种方式有点类似于穷举法，但是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值