回溯法刷题ing

最新推荐文章于 2023-02-23 20:23:34 发布
最新推荐文章于 2023-02-23 20:23:34 发布
阅读量143 收藏 1
点赞数 1
分类专栏： 算法题 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44173974/article/details/107536171
版权

##回溯法##

回溯法总结

1.DFS和回溯算法区别

DFS是一个劲的往某一个方向搜索，而回溯算法建立在DFS基础之上的，但不同的是在搜索过程中，达到结束条件后，恢复状态，回溯上一层，再次搜索。因此回溯算法与DFS的区别就是有无状态重置

2.何时使用回溯算法

** 当问题需要"回头"，以此来查找出所有的解的时候**，使用回溯算法。即满足结束条件或者发现不是正确路径的时候(走不通)，要撤销选择，回退到上一个状态，继续尝试，直到找出所有解为止

3.怎么样写回溯算法(从上而下，※代表难点)

①画出递归树，找到状态变量(回溯函数的参数)，这一步非常重要※
②根据题意，确立结束条件
③找准选择列表(与函数参数相关),与第一步紧密关联※
④判断是否需要剪枝
⑤作出选择，递归调用，进入下一层
⑥撤销选择

4.回溯问题的类型

类型题目链接
子集、组合子集、子集 II、组合、组合总和、组合总和 II
全排列全排列、全排列 II、字符串的全排列、字母大小写全排列
搜索解数独、单词搜索、N皇后、分割回文串、二进制手表

4.1子集、组合

子集

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

**说明：**解集不能包含重复的子集。

输入: nums = [1,2,3]
输出:
[
[3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

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

子集2

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

**说明：**解集不能包含重复的子集。

输入: [1,2,2]
输出:
[
[2],
[1],
[1,2,2],
[2,2],
[1,2],
[]
]

加了剪枝

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

组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

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

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
[7],
[2,2,3]
]

输入: candidates = [2,3,5], target = 8,
所求解集为:
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

class Solution {
public:
    vector<vector<int>> res;
    void dfs(vector<int>& candidates,vector<int>& path, int index,int sum,int target){
        if(sum==target){
            res.push_back(path);
            return;
        }
        for (int i = index; i <candidates.size() ; ++i) {
            if(sum>target)
                continue;
            path.push_back(candidates[i]);
            dfs(candidates,path,i,sum+candidates[i],target);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<int> path;
        dfs(candidates,path,0,0,target);
        set<vector<int>> temp(res.begin(),res.end());
        res.assign(temp.begin(),temp.end());
        return res;
    }
};

分割回文串 嘿嘿

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

输入: "aab"
输出:
[
["aa","b"],
["a","a","b"]
]

class Solution {
public:
    vector<vector<string>> res;
    void backtrack(string s,vector<string>& parts,int index){
        if(index==s.size()){
            res.push_back(parts);
            return;
        }
        string temp1;
        for (int i = index; i <s.size() ; ++i) {
            temp1+=s[i];
            string temp2=temp1;
            reverse(temp2.begin(),temp2.end());
            if(temp2==temp1){
                parts.push_back(temp1);
                backtrack(s,parts,i+1);
                parts.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s) {
        vector<string> parts;
        backtrack(s,parts,0);
        return res;
    }
};

电话号码的字母组合

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e1XhLRhc-1595485861554)(C:\Users\86178\Desktop\力扣\图片\2020-05-21_213228.png)]

自己写的
class Solution {
public:
    unordered_map<char,string> map{
            {'2',"abc"},{'3',"def"},{'4',"ghi"},{'5',"jkl"},{'6',"mno"},{'7',"pqrs"},{'8',"tuv"},{'9',"wxyz"}
    };
    vector<string> res;

    void tracbeck(string digits,int index,string& path){
        if(index==digits.size()){
            if(path.size()==digits.size())
                res.push_back(path);
            return;
        }
        string words;
        for (int i = index; i <digits.size() ; ++i) {
            words=map[digits[index]];
            for (int j = 0; j < words.size(); ++j) {
                path+=words[j];
                tracbeck(digits,i+1,path);
                path.erase(path.end()-1);
            }
        }
    }
    vector<string> letterCombinations(string digits) {
        if(digits=="")
            return res;
        string path;
        tracbeck(digits,0,path);
        return res;
    }
};
看了题解优化了
class Solution {
public:
    unordered_map<char,string> map{
            {'2',"abc"},{'3',"def"},{'4',"ghi"},{'5',"jkl"},{'6',"mno"},{'7',"pqrs"},{'8',"tuv"},{'9',"wxyz"}
    };
    vector<string> res;
    string path;

    void tracbeck(string digits,int index){
        if(index==digits.size()){
            res.push_back(path);
            return;
        }
        for (int j = 0; j < map[digits[index]].size(); ++j) {
            path.push_back(map[digits[index]][j]);
            tracbeck(digits,index+1);
            path.pop_back();
        }
    }
    vector<string> letterCombinations(string digits) {
        if(digits.size()==0)
            return res;
        tracbeck(digits,0);
        return res;
    }
};

无重复字符串的排列组合

无重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合，字符串每个字符均不相同。

输入：S = "qwe"
输出：["qwe", "qew", "wqe", "weq", "ewq", "eqw"]
标准回溯
class Solution {
public:
    vector<string> res;
    void backtrack(string S,string& path,vector<int>& flag,int index){
       if(index==S.size()){
           res.push_back(path);
           return;
       }
        for (int i = 0; i < S.size(); ++i) {
            if(flag[i])
                continue;
            path.push_back(S[i]);
            flag[i]=1;
            backtrack(S,path,flag,index+1);
            path.pop_back();
            flag[i]=0;
        }
    }
    vector<string> permutation(string S) {
        string path;
        vector<int> flag(S.size(),0);
        backtrack(S,path,flag,0);
        return res;
    }
};
回溯2
class Solution {
public:
    vector<string> res;
    void backtrack(string S,int index){
        if(index==S.size()){
            res.push_back(S);
            return;
        }
        for (int i = index; i <S.size() ; ++i) {
            string temp=S;
            swap(temp[index],temp[i]);
            backtrack(temp,index+1);
        }
    }
    vector<string> permutation(string S) {
        string path;
        backtrack(S,0);
        return res;
    }
};

无重复字符串的排列组合2

有重复字符串的排列组合

使用set去重
class Solution {
public:
    set<string> res;
    void backtrack(string S,string& path,vector<int>& flag){
       if(path.size()==S.size()){
           res.insert(path);
           return;
       }
        for (int i = 0; i < S.size(); ++i) {
            if(flag[i]==0){
                path.push_back(S[i]);
                flag[i]=1;
                backtrack(S,path,flag);
                path.pop_back();
                flag[i]=0;
            }
        }
    }
    vector<string> permutation(string S) {
        string path;
        vector<int> flag(S.size(),0);
        backtrack(S,path,flag);
        vector<string> temp(res.begin(),res.end());
        return temp;
    }
};
剪枝去重

思路

多了一个排序和剪枝函数
排序使得重复的在一起
剪枝讲解：
1、因为i-1的存在 所以i>0
2、S[i]==S[i-1] && flag[i-1]==0表示这个i的子树i-1都经历过了 且是刚经历
	在递归树中可以看出这个特点 
if(i>0 && S[i]==S[i-1] && flag[i-1]==0)
             continue;

class Solution {
public:
    vector<string> res;
    void backtrack(string S,string& path,vector<int>& flag,int index){
        if(index==S.size()){
            res.push_back(path);
            return;
        }
        for (int i = 0; i < S.size(); ++i) {
            if(flag[i])
                continue;
            if(i>0 && S[i]==S[i-1] && flag[i-1]==0)
                continue;
            path.push_back(S[i]);
            flag[i]=1;
            backtrack(S,path,flag,index+1);
            path.pop_back();
            flag[i]=0;
        }
    }
    vector<string> permutation(string S) {
        string path;
        vector<int> flag(S.size(),0);
        sort(S.begin(),S.end());
        backtrack(S,path,flag,0);
        return res;
    }
};

4.2搜索

二进制手表顶部有 4 个 LED 代表小时（0-11），底部的 6 个 LED 代表分钟（0-59）。

每个 LED 代表一个 0 或 1，最低位在右侧。

给定一个非负整数 n 代表当前 LED 亮着的数量，返回所有可能的时间。

输入: n = 1
返回: ["1:00", "2:00", "4:00", "8:00", "0:01", "0:02", "0:04", "0:08", "0:16", "0:32"]

注意事项:

输出的顺序没有要求。
小时不会以零开头，比如 “01:00” 是不允许的，应为 “1:00”。
分钟必须由两位数组成，可能会以零开头，比如 “10:2” 是无效的，应为 “10:02”。

思路：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rd0rcmW5-1595485861557)(C:\Users\86178\Desktop\力扣\图片\2020-05-20_144911.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iv6xggWh-1595485861558)(C:\Users\86178\Desktop\力扣\图片\2020-05-20_144926.png)]

class Solution {
public:
    vector<string> res;
    unordered_map<int ,int> hash={
            {0,1},{1,2},{2,4},{3,8},{4,1},{5,2},{6,4},{7,8},{8,16},{9,32}
    };
    void backtrak(int num,int index,pair<int,int>& time){
        if(num==0){
            if(time.first>11 || time.second>59)
                return;
            string hour=to_string(time.first);
            string minute=to_string(time.second);
            if(minute.size()==1)
                minute.insert(0,"0");
            res.push_back(hour+":"+minute);//构造格式
        }
        for (int i = index; i <10 ; ++i) {
            if(time.first>11 || time.second>59)
                continue;
            pair<int,int> temp=time;//保存状态
            if(i<4)
                time.first+=hash[i];
            else
                time.second+=hash[i];
            backtrak(num-1,i+1,time);//进入下一层，注意下一层的start是i+1，即从当前灯的下一盏开始
            time=temp;//恢复状态
        }
    }
    vector<string> readBinaryWatch(int num) {
        pair<int,int> time(0,0);
        backtrak(num,0,time);
        return res;
    }
};

22. 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例：

输入：n = 3
输出：[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]

深搜

class Solution {
public:
    vector<string> res;
    void dfs(string path, int n, int lc, int rc){
        if(rc>lc || lc>n || rc>n) return;
        if(lc==rc && lc==n){
            res.push_back(path);
            return;
        }
        dfs(path + '(', n, lc + 1, rc);
        dfs(path + ')', n, lc, rc + 1);
    }
    vector<string> generateParenthesis(int n) {
        int lc=0;//左括号个数
        int rc=0;//右括号个数
        string path="";
        dfs(path, n, lc, rc);
        return res;
    }
};

回溯

class Solution {
public:
    vector<string> res;
    void backtrack(string& path,int n,int lc,int rc){
        if(path.size()==n*2){
            res.push_back(path);
            return;
        }
        if(lc<n){
            path.push_back('(');
            backtrack(path,n,lc+1,rc);
            path.pop_back();
        }
        if(rc<lc){
            path.push_back(')');
            backtrack(path,n,lc,rc+1);
            path.pop_back();
        }
    }
    vector<string> generateParenthesis(int n) {
        int lc=0;//左括号个数
        int rc=0;//右括号个数
        string path="";
        backtrack(path,n,lc,rc);
        return res;
    }
};
可乐大牛
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
回溯法
01-06
回溯法(探索与回溯法)是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个...
C++回溯法实例分析
01-20
本文实例讲述了C++的回溯法，分享给大家供大家参考之用。具体方法分析如下： 一般来说，回溯法是一种枚举状态空间中所有可能状态的系统方法，它是一个一般性的算法框架。 解向量a=(a1, a2, …, an)，其中每个元素ai...
回溯算法的题型以及相应解题技巧
weixin_44499544的博客
01-06 188
下面提供一些我做过的「回溯」算法的问题，以便大家学习和理解「回溯」算法。 题型一： 排列、组合、子集相关问题。 提示：这部分练习可以帮助我们熟悉「回溯算法」的一些概念和通用的解题思路。解题的步骤是：先画图，再编码。去思考可以剪枝的条件， 为什么有的时候用 used 数组，有的时候设置搜索起点 begin 变量，理解状态变量设计的想法。 全排列（中等） 全排列 II（中等）：思考为什么造成了重复，如何在搜索之前就判断这一支会产生重复； 组合总和（中等） 组合总和 II（中等） 组合（中等）
【数据结构和算法】【刷题】回溯法
sinat_37500899的博客
09-19 172
1.回溯法 参考1.【罗兵：python 回溯法 记录】 2.【大红豆小薏米 讲解视频】 2.leetcode 78.子集 给定一组不含重复元素的整数数组nums，返回该数组所有可能的子集（幂集）。 说明：解集不能包含重复的子集。 示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3...
刷题计划——回溯法(一)
Frank的博客
04-26 319
47. 全排列(中等) 题目： 给定一个没有重复数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 作为一道经典的回溯法题目，全排列的问题时回溯法入门的基础。 首先，给定一个没有重复数字，总长为N的序列，其可能的排列组合为ANN−1...
回溯法刷题入门总结
qq_35027690的博客
06-17 260
初看回溯时，觉得超级难以理解，也许是自己太笨了。后来看到大佬的总结，跟着他一步一步从基础题型入手，才慢慢掌握了一点点回溯法的技巧，这里做一个自己的学习总结，凡事还是得脚踏实地一步一步刷起。 如有错误恳请多多指正。 参考:「leetcode」最强回溯算法总结篇！历时21天、画了20张树形结构图、14道精选回溯题目精讲 1.回溯法基本框架 关于回溯法的伪代码，leecode及百度上有很多文章总结过，以c++的vector为例如下 定义 result 数组 定义 path 数组 void backtrack(
[java] 回溯算法+剪枝
浅夜
01-03 833
814. 二叉树剪枝 题目 给定二叉树根结点 root ，此外树的每个结点的值要么是 0，要么是 1。 返回移除了所有不包含 1 的子树的原二叉树。 ( 节点 X 的子树为 X 本身，以及所有 X 的后代。) 示例1: 输入: [1,null,0,0,1] 输出: [1,null,0,null,1] 解释: 只有红色节点满足条件“所有不包含 1 的子树”。 右图为返回的答案。 说明: 给定的二叉树最多有 100 个节点。 每个节点的值只会为 0 或 1 。 思路 用递归，函数体的意思就是给根节
动态规划刷题ing
可乐大牛的博客
07-23 708
##动态规划## 最大子序和 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 输入: [-2,1,-3,4,-1,2,1,-5,4], 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 暴力法 int max_fun(int a,int b){ return a>b?a:b; } int sumOfArray(int* nums,int left,int right){ int sum
Jozky 刷题目录
qq_35975367的博客
03-23 735
文章目录 第一章 字符串问题 第二章 博弈论 第三章 计算几何 第四章 网络流 第五章 动态规划 第六章 数论 第七章 图论 第八章 数据结构 第九章 其他算法 第十章 贪心（思维题/构造题）
LeetCode究极刷题班
weixin_50385926的博客
01-02 276
LeetCode究极刷题班ing
LeetCode刷题笔记 - 回溯法篇
qq_44243071的博客
02-23 74
LeetCode刷题笔记-回溯法篇
python 回溯法模板详解
09-17
今天小编就为大家分享一篇python 回溯法模板详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
八皇后回溯法
12-07
八皇后回溯法，八皇后回溯法课件，八皇后回溯法PPT
【acwing算法基础课】 数学知识 分解质因数
可乐大牛的博客
02-22 1200
题目来源：分解质因数 题目描述 给定n个正整数ai，将每个数分解质因数，并按照质因数从小到大的顺序输出每个质因数的底数和指数。 输入格式 第一行包含整数n。 接下来n行，每行包含一个正整数ai。 输出格式 对于每个正整数ai,按照从小到大的顺序输出其分解质因数后，每个质因数的底数和指数，每个底数和指数占一行。 每个正整数的质因数全部输出完毕后，输出一个空行。 数据范围 1≤n≤100, 1≤ai≤2∗109 输入样例： 2 6 8 输出样例： 2 1 3 1 2 3 思路 遍历所有质数，然后把它除干净
LeetCode究极班系列(21-25)
可乐大牛的博客
10-05 974
21. 合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 递归 class Solution { public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { if(l1==nullptr) return l2;
c++的ios::sync_with_stdio(false)；和cin.tie(0)；
可乐大牛的博客
08-29 579
最近才知道 使用ios::sync_with_stdio(false);这行代码关掉输入输出的缓冲区之后 cin 和cout的效率与scanf与printf相差无几 很棒！
【acwing 寒假每日一题（入门组）】day33 数字统计
可乐大牛的博客
02-21 543
题目来源：数字统计 题目描述 请统计某个给定范围[L, R]的所有整数中，数字 2 出现的次数。 比如给定范围[2, 22]，数字 2 在数 2 中出现了 1 次，在数 12 中出现 1 次，在数 20 中出现 1 次，在数 21 中出现 1 次，在数 22 中出现 2 次，所以数字 2 在该范围内一共出现了 6 次。 输入格式 输入共 1 行，为两个正整数 L 和 R，之间用一个空格隔开。 输出格式 输出共 1 行，表示数字 2 出现的次数。 数据范围 1≤L≤R≤10000 输入样例： 2 22 输出
【acwing 寒假每日一题（入门组）】day20 火星人
可乐大牛的博客
02-10 466
题目来源：火星人 题目描述 人类终于登上了火星的土地并且见到了神秘的火星人。 人类和火星人都无法理解对方的语言，但是我们的科学家发明了一种用数字交流的方法。 这种交流方法是这样的，首先，火星人把一个非常大的数字告诉人类科学家，科学家破解这个数字的含义后，再把一个很小的数字加到这个大数上面，把结果告诉火星人，作为人类的回答。 火星人用一种非常简单的方式来表示数字——掰手指。 火星人只有一只手，但这只手上有成千上万的手指，这些手指排成一列，分别编号为1，2，3……。 火星人的任意两根手指都能随意交换位置，他们就
穷举法 分治法 回溯法
最新发布
05-10
穷举法、分治法和回溯法都是算法设计思想。 穷举法又称暴力搜索法，它的思想是将所有可能的情况都枚举出来，然后一一验证，找到符合条件的解。虽然穷举法的时间复杂度较高，但它是一种简单、可靠的算法。 分治法是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值