day29 C++ 回溯算法 递增子序列 全排列 全排列Ⅱ

最新推荐文章于 2024-09-27 14:28:55 发布
最新推荐文章于 2024-09-27 14:28:55 发布
阅读量101 收藏
点赞数
文章标签： 算法 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43773652/article/details/134364146
版权

题目1：491 递增子序列

题目链接：递增子序列

对题目的理解

整数数组中递增子序列，递增子序列中至少有两个元素，数组中存在重复元素，若两整数相等也是一种情况

本题求自增子序列，是不能对原数组进行排序的，不能使用之前的去重逻辑！

这道题就没办法使用以前used去重思想了，因为数组不允许排序，所有uesd无用武之地

思维图

回溯法

回溯三部曲

i）递归函数参数

本题求子序列，元素不能重复使用，所以需要startIndex，调整下一层递归的起始位置。

ii）终止条件

本题其实类似求子集问题，也是要遍历树形结构找每一个节点，可以不加终止条件，startIndex每次都会加1，并不会无限递归。

但本题收集结果有所不同，题目要求递增子序列大小至少为2，所以收集结果的地方要加限制条件

iii）单层搜索逻辑

同一父节点下的同层上使用过的元素就不能再使用了；

unordered_set<int> uset; 是记录本层元素是否重复使用，新的一层uset都会重新定义（清空），uset只负责本层！

可以直接在每一层的for循环取数的过程中，查找该层的的uset中的值是否出现过，不用纠结在别的层出现过的情况，因为uset就是每一层会定义一个，所以uset只会排除该树层中的相同元素出现的情况，不会排除掉不在同一树层的情况，所以，可以放心使用

代码

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums,int startindex){
        //收获结果
        if(path.size()>=2) result.push_back(path);
        //终止条件，可写可不写
        if(startindex>=nums.size()) return;
        unordered_set<int> uset;
        //单层遍历逻辑
        for(int i=startindex;i<nums.size();i++){
            if((!path.empty() && nums[i]<path.back()) || uset.find(nums[i])!=uset.end()) continue;
            path.push_back(nums[i]);
            uset.insert(nums[i]);
            backtracking(nums,i+1);//递归
            path.pop_back();//回溯
            
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        path.clear();
        result.clear();
        backtracking(nums,0);
        return result;
        

    }
};
  • 时间复杂度: O(n * 2^n)
  • 空间复杂度: O(n)

使用数组进行优化

用数组做哈希问题，效率会高很多

数组进行去重和set进行去重的道理相同，也是在每一层定义一个数组，这个数组只会去重每一层的相同元素出现的情况，不会排除掉不同层相同元素的情况，所以，可以放心使用

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums,int startindex){
        //收获结果
        if(path.size()>=2) result.push_back(path);
        //终止条件，可写可不写
        if(startindex>=nums.size()) return;
        int unums[201]={0};//题目中说数组的元素大小在-100~100之间,在每一层都会定义一个unums
        //单层遍历逻辑
        for(int i=startindex;i<nums.size();i++){
            if((!path.empty() && nums[i]<path.back()) || unums[nums[i]+100]==1) continue;
            path.push_back(nums[i]);
            unums[nums[i]+100]=1;//nums[i]的范围在-100~100之间，所以nums[i]+100在0~200之间
            backtracking(nums,i+1);//递归
            path.pop_back();//回溯  
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        path.clear();
        result.clear();
        backtracking(nums,0);
        return result;
        

    }
};

题目2：46 全排列

题目链接：全排列

对题目的理解

数组中不含重复元素，返回所有可能的全排列

思维图

回溯法

回溯三部曲

i）递归函数参数

首先排列是有序的，也就是说 [1,2] 和 [2,1] 是两个集合，这和之前分析的子集以及组合所不同的地方，所以处理排列问题就不用使用startIndex了，但排列问题需要一个used数组，标记已经选择的元素。

ii）递归终止条件

叶子节点，就是收割结果的地方。当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。

iii）单层搜索的逻辑

和组合问题最大的不同就是for循环里不用startindex了。

因为排列问题，每次都要从头开始搜索，例如元素1在[1,2]中已经使用过了，但是在[2,1]中还要再使用一次1。

而used数组，其实就是记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次。

代码

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(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]==true) continue;//代表元素已经用过
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used = vector(nums.size(), false);
        backtracking(nums,used);
        return result;
    }
};
  • 时间复杂度: O(n!)
  • 空间复杂度: O(n)

总结（与组合问题不同之处在于）

  • 每层都是从0开始搜索而不是startIndex
  • 需要used数组记录path里都放了哪些元素了

题目3：47 全排列Ⅱ

题目链接：全排列Ⅱ

对题目的理解

数组中包含重复元素，返回全排列，不重复

注意本题与上一题的区别在于要对元素进行去重，求全排列时可以对数组中的元素进行排序

所以本题就是上一题全排列与去重的结合

思维图

组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。

代码使用used数组进行去重,记得进行排序

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(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(i>0 && nums[i]==nums[i-1] && used[i-1]==false) continue;
            if(used[i]==true) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtracking(nums,used);
        return result;
    }
};

代码2，只是在used的判断条件上进行改变，不使用continue了

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(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(i>0 && nums[i]==nums[i-1] && used[i-1]==false) continue;
            if(used[i]==false){
                path.push_back(nums[i]);
                used[i]=true;
                backtracking(nums,used);
                used[i]=false;
                path.pop_back();
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used(nums.size(),false);
        //对数组进行排序
        sort(nums.begin(),nums.end());
        backtracking(nums,used);
        return result;
    }
};
  • 时间复杂度: O(n! * n)
  • 空间复杂度: O(n)

扩展

在去重方面做文章，不过前面使用一个used数组就可以完成，再重新定义一个哈希结构没有必要，就是为了多练习几种去重方法，熟悉一下

使用set数组进行去重，就是比较耗时

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums,vector<bool>& used){
        //终止条件
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        unordered_set<int> uset;//进行每一层的去重操作
        //单层搜索逻辑
        for(int i=0;i<nums.size();i++){
            if(uset.find(nums[i])!=uset.end()) continue;
            if(used[i]==false){
                path.push_back(nums[i]);
                used[i]=true;
                uset.insert(nums[i]);
                backtracking(nums,used);
                used[i]=false;
                path.pop_back();
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return result;
    }
};

也可以使用数组进行去重

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums,vector<bool>& used){
        //终止条件
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        int unum[21] = {0};//使用数组进行每一层的去重操作，因为数组的值有范围
        //单层搜索逻辑
        for(int i=0;i<nums.size();i++){
            if(unum[10+nums[i]]==1) continue;
            if(used[i]==false){
                path.push_back(nums[i]);
                used[i]=true;
                unum[10+nums[i]] = 1;
                backtracking(nums,used);
                used[i]=false;
                path.pop_back();
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return result;
    }
};

人来茶热
关注
Day29.全排列、递增子序列
izwmain的博客
11-23 106
代码随想录，第29天
Day29【回溯算法】491.递增子序列、46.全排列、47.全排列II
yangjihua的个人笔记博客
05-03 109
排列问题和组合问题的区别在于站在某节点可选择路径的区别； 注意去重的套路
回溯算法day24| 491.递增子序列、46. 全排列、47. 全排列 II
2402_84438596的博客
09-10 946
回溯算法day24| 491.递增子序列、46. 全排列、47. 全排列 II
算法Day29 | 491.递增子序列，46.全排列，47.全排列 II
雨后的放线君
06-07 701
zsbd
代码随想录算法训练营DAY29(记录)|C++回溯算法Part.5|491.递增子序列、46.全排列、47.全排列II
糖炒栗子
04-17 964
也就是本题的递增子序列有要求子集，然后还要去重，但是：本题求自增子序列，是不能对原数组进行排序的，排完序的数组都是自增子序列了。从树形结构可以看出，我们每次都是从头开始，即使元素1在[1,2]中已经使用过了，但是在[2,1]中还要再使用一次1。递归函数参数：求子序列，很明显一个元素不能重复使用，所以需要startIndex，调整下一层递归的起始位置。这里我们会使用used数组，记录此时path里都有哪些元素使用啦，一个排列里一个元素只能使用一次。那么我们这里要判断了，是树层去重呢，还是树枝去重？
Day29| 491.递增子序列 | 46.全排列 | 47.全排列 II
qq_46385921的博客
11-13 190
回溯打卡
DAY29！||递增子序列，全排列，全排列Ⅱ
今天也是要加油的一天
08-10 59
给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素。输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列。
代码随想录刷题day29 491.递增子序列；46.全排列；47.全排列 II
weixin_43127049的博客
11-09 375
代码随想录刷题day29
【刷题day29】回溯|491. 递增子序列、46. 全排列、47. 全排列 II
weixin_45639929的博客
03-21 143
力扣
代码随想录算法训练营Day22 | 491.递增子序列，46.全排列，47.全排列 II ，332. 重新安排行程，51. N皇后，37. 解数独，总结
little__penguin的博客
07-07 446
【C++21天养成计划】STL算法超全整理！（Day18）
热门推荐
不积跬步，无以至千里！
10-04 1万+
横扫STL算法，帅翻全场！
C/C++ 时间戳转为年月日时分秒算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-07 7689
时间戳是指从某一固定的时间点开始计算的总秒数。
C/C++ 两个日期之间的天数算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-07 7486
【代码】C/C++ 两个日期之间的天数算法详解及源码。
254.【2023华为OD机试真题】-任务处理（贪心算法-Java&Python&C++&JS实现）
一键难忘的博客
01-26 1万+
【2023华为OD机试真题】-任务处理（贪心算法-Java&Python&C++&JS实现） 在某个项目中有多个任务（用 tasks 数组表示）需要您进行处理，其中 tasks[i] = [si, ei]，你可以在 si
二叉树最小深度
2301_80161204的博客
09-27 444
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1258
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
最新发布
YQ20210216的博客
09-27 354
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
【优选算法】（第一篇）
weixin_73861555的博客
09-25 1083
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
C++实现的电子日历功能：设置、输出、加一天、判断闰年
"这是一个使用C++编程语言实现的控制台电子日历程序，它具备设置日期、输出日期、日期加一天、查询任意一天是星期几（通过基姆拉尔森公式）以及判断是否为闰年等功能。" 在C++编程中，这个日历程序主要涉及以下几个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值