算法学习——LeetCode力扣回溯篇3（491. 非递减子序列、46. 全排列、47. 全排列 II、332. 重新安排行程）

已于 2024-03-31 18:45:47 修改
阅读量1.1k 收藏 15
点赞数 8
分类专栏： LeetCode算法学习 文章标签： 算法 学习 leetcode c++ c
于 2024-02-14 22:26:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44814825/article/details/136116631
版权

算法学习——LeetCode力扣回溯篇3

在这里插入图片描述

491. 非递减子序列

491. 非递减子序列 - 力扣（LeetCode）

描述

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

示例 2：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]

提示

  • 1 <= nums.length <= 15
  • -100 <= nums[i] <= 100

代码解析

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    
    void backtracking(vector<int>& nums , int indnx )
    {
    	//小于2的不加入结果，至少两个
        if(path.size()>=2) result.push_back(path);
        if(indnx >= nums.size()) return;
		//用set统计每一层相同值元素的使用
        unordered_set<int> uset;
        for(int i =indnx ; i<nums.size(); i++)
        {
        	//如果当前值小于上一个，或者这个值在该层用过了，跳过
            if(path.empty() == 0 && nums[i] < path.back() 
                || uset.find(nums[i]) != uset.end()) 
            continue;
            //将该使用过的存入set，标记使用过
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums,i+1 );
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return result;
    }
};

46. 全排列

46. 全排列 - 力扣（LeetCode）

描述

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例

示例 1：

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

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]

提示

  • 1 <= nums.length <= 6
  • -10 <= nums[i] <= 10
  • nums 中的所有整数 互不相同

代码解析

回溯法
class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int> &nums)
    {
        if(path.size() == nums.size())
        {
            result.push_back(path);
            return;
        } 
        for(int i = 0 ; i<nums.size() ; i++)
        {
           auto it = find(path.begin(),path.end(),nums[i]);
           //如果这个元素在这个树枝之前用过，就跳出
           if(it == path.end()) 
           {
               path.push_back(nums[i]);
           }else
           {
               continue;
           }
            backtracking(nums);
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> permute(vector<int>& nums) {
        backtracking(nums);
        return result;
    }
};
回溯标记法

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    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里已经收录的元素，直接跳过
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

47. 全排列 II

47. 全排列 II - 力扣（LeetCode）

描述

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]

示例 2：

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

提示

  • 1 <= nums.length <= 8
  • -10 <= nums[i] <= 10

代码解析

回溯标记法（不去重，时间复杂度高）

在插入之前做一个find查找，找不到相同的插入

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums , vector<bool>& used)
    {
        if(path.size() == nums.size())
        {
            if(find(result.begin() , result.end() , path) == result.end() ) result.push_back(path);
            return;
        }

        for(int i=0 ; i<nums.size() ;i++)
        {
            if(used[i] == 1) continue;

            used[i]=1;
            path.push_back(nums[i]);
            backtracking(nums,used);
            path.pop_back();
            used[i]=0;
        }
        return;
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return result;
    }
};
回溯去重
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    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++) {
            // used[i - 1] == true，说明同一树枝nums[i - 1]使用过
            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
            // 如果同一树层nums[i - 1]使用过则直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) //去重
            {
                continue;
            }
            if (used[i] == false) {
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                path.pop_back();
                used[i] = false;
            }
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 排序
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};
树层去重
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)
{
    continue;
}

在这里插入图片描述

树枝去重
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true)
{
    continue;
}

在这里插入图片描述

332. 重新安排行程

332. 重新安排行程 - 力扣（LeetCode）

描述

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”] 相比就更小，排序更靠前。
假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。

示例

示例 1：
在这里插入图片描述

输入：tickets = [[“MUC”,“LHR”],[“JFK”,“MUC”],[“SFO”,“SJC”],[“LHR”,“SFO”]]
输出：[“JFK”,“MUC”,“LHR”,“SFO”,“SJC”]

示例 2：

在这里插入图片描述

输入：tickets = [[“JFK”,“SFO”],[“JFK”,“ATL”],[“SFO”,“ATL”],[“ATL”,“JFK”],[“ATL”,“SFO”]]
输出：[“JFK”,“ATL”,“JFK”,“SFO”,“ATL”,“SFO”]
解释：另一种有效的行程是 [“JFK”,“SFO”,“ATL”,“JFK”,“ATL”,“SFO”] ，但是它字典排序更大更靠后。

提示

  • 1 <= tickets.length <= 300
  • tickets[i].length == 2
  • fromi.length == 3
  • toi.length == 3
  • fromi 和 toi 由大写英文字母组成
  • fromi != toi

代码解析

回溯遍历（超时）

回溯遍历每一种可能
当出现第一种可能的路线，之间加入。
当出现新的可能路线，与老路线对比，如果字典排序小于，则替换老路线

class Solution {
public:
    vector<string> resul;
    vector<string> path;
    void backtraking(vector<vector<string>>& tickets , string Indnx ,  vector<bool> &used)
    {
    	//找到路线，看是否替换老的路径
    	//如果没有老路径直接加入，如果相同就返回，如果不同路径按照字典比较
        if(path.size()==tickets.size()+1)
        {
            if(resul.empty()==1) 
            {
                resul = path;
                return;
            }
            else if(resul == path) return;
            else 
            {
                for(int j=0 ;j<path.size();j++)
                {
                    for(int k=0 ;k<3;k++)
                    {
                        if(resul[j][k] == path[j][k]) continue;
                        else if(resul[j][k] < path[j][k])return;
                        else if(resul[j][k] > path[j][k]) 
                        {
                            resul.clear();
                            resul = path;
                            return;
                        }
                    }
                }
            }
            // cout<<"resu: ";
            // for(auto i:resul) cout<<i<<' ';
            // cout<<endl;
            return;
        }

        for(int i=0 ; i<tickets.size();i++)
        {
        	//如果当前机票使用过，或者当前机票目的地不对，跳过
            if(used[i]==true || tickets[i][0] != Indnx) continue;
            //如果当前机票可用，则加入路径
            if(used[i]== false && tickets[i][0] == Indnx)
            {
                used[i] = true;
                path.push_back(tickets[i][1]);
                //递归，确定递归找的新机票。下一站机票的开始机场，就是当前机票的目的地机场
                backtraking(tickets,tickets[i][1],used);
                used[i] = false;
                path.pop_back();
            }
        }
        return;
        
    }
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        vector<bool> used(tickets.size(),false);
        path.push_back("JFK");
        backtraking(tickets,"JFK",used);
        return resul;
    }
};
排序再回溯

先对输入票排序，其中排序按照票的目的地的字典减少排序（因为出发点是确定的，目的地多种找最优解）
之后回溯遍历找路线，发现的第一个路线即为最优路线

class Solution {
public:
	//按飞机票目的地（字符串vector第二个参数）字典减小排序
     class compare
    {
    public:
        bool operator()( const vector<string> tickets1 ,const  vector<string> tickets2 )
        {
           
            if((tickets1[1])[0]  < (tickets2[1])[0]) return 1;
            else if((tickets1[1])[0]  == (tickets2[1])[0])
            {
                if((tickets1[1])[1]  < (tickets2[1])[1]) return 1;
                else if((tickets1[1])[1]  == (tickets2[1])[1])
                {
                    if((tickets1[1])[2]  < (tickets2[1])[2]) return 1;
                    else return 0;
                }
                 return 0;
            }
            return 0;
           
        }
    };
    vector<string> resul;
    vector<string> path;
    bool find = false;
    void backtraking(vector<vector<string>>& tickets , string Indnx ,  vector<bool> &used)
    {
    	//找到一个路径就不找了，直接是最优路径
        if(find == true ) return;
        if(path.size()==tickets.size()+1)
        {
                resul = path;
                find =true;
                return;
        }

        for(int i=0 ; i<tickets.size();i++)
        {
            if(used[i]==true || tickets[i][0] != Indnx) continue;
            if(used[i]== false && tickets[i][0] == Indnx)
            {
                used[i] = true;
                path.push_back(tickets[i][1]);
                backtraking(tickets,tickets[i][1],used);
                used[i] = false;
                path.pop_back();
            }
        }
        return;
        
    }
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        vector<bool> used(tickets.size(),false);
        sort(tickets.begin(),tickets.end(),compare());
        // for(auto i:tickets) 
        // {
        //      cout<<'[';
        //     for(auto j:i)
        //     {
        //          cout<<j<<' ';
        //     }
        //      cout<<']';
        // }
           
        path.push_back("JFK");
        backtraking(tickets,"JFK",used);
        return resul;
    }
};
拉依达的嵌入式小屋
关注
专栏目录
算法训练营day25--491.非递减子序列+46.全排列+47.全排列 II
qq_42029265的博客
07-08 1127
491.非递减子序列+46.全排列+47.全排列 II
代码随想录算法训练营第 25 天 | LeetCode491.递增子序列 LeetCode46.全排列 LeetCode47.全排列ii
2301_79647020的博客
07-27 911
递增子序列、全排列和回溯的一些总结
算法学习——LeetCode力扣补充篇13（662. 二叉树最大宽度、152. 乘积最大子数组、153. 寻找旋转排序数组中的最小值）
拉依达不拉跨的博客
04-18 842
算法学习——LeetCode力扣补充篇13（662. 二叉树最大宽度、152. 乘积最大子数组、153. 寻找旋转排序数组中的最小值）
代码随想录刷题day25丨491.递增子序列 ，46.全排列 ，47.全排列 II
m0_75195038的博客
09-07 685
题目链接：491. 非递减子序列 - 力扣（LeetCode）视频讲解：回溯算法精讲，树层去重与树枝去重 | LeetCode：491.递增子序列_哔哩哔哩_bilibili文档讲解：https://programmercarl.com/0491.%E9%80%92%E5%A2%9E%E5%AD%90%E5%BA%8F%E5%88%97.html解题思路：回溯用[4, 7, 6, 7]这个数组来举例，抽象为树形结构如图：代码： 总结：题目链接：46. 全排列 - 力扣（LeetCode）视频讲解：组合与
代码随想录算法训练营Day25 | Leetcode 491 非递减子序列 Leetcode 46 全排列 Leetcode 47 全排列Ⅱ
m0_74853141的博客
08-10 873
思路：这道题里面数组是可以有重复元素的，也就是不仅要避免树枝上的重复元素不能被选，还要保证同一树层的元素不能重复被选。思路：这个题目也是不能重复用，那么为什么不能用used数组？因为这个题目不允许将原数组排序，所以必须用set。思路：排列问题不需要index，因为其中的元素还需要重复取。
【回溯 - 2】47. 全排列 II
Smileyan's blog
07-14 2238
力扣刷题，回溯类算法例题
LeetCode刷题复盘笔记——46. 全排列（一文搞懂回溯解决全排列问题上篇）
Lucky_Alan_Gareth的博客
10-29 1494
LeetCode刷题复盘笔记——46. 全排列（一文搞懂回溯解决全排列问题上篇）。可以看出元素1在[1,2]中已经使用过了，但是在[2,1]中还要在使用一次1，所以处理排列问题就不用使用startIndex了。每层都是从0开始搜索而不是startIndex排列问题需要一个used数组，标记已经选择的元素，而used数组，其实就是记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次。排列问题是回溯算法解决的经典题目，大家可以好好体会体会。
Leetcode算法Java全解答--47. 全排列 II
cmqwan的博客
12-05 8145
Leetcode算法Java全解答–47. 全排列 II 文章目录Leetcode算法Java全解答--47. 全排列 II题目想法结果总结代码我的答案大佬们的答案测试用例其他 题目 给定一个可包含重复数字的序列，返回所有不重复的全排列。 示例 输入: [1,1,2] 输出: [ [1,1,2], [1,2,1], [2,1,1] ] 想法 利用046的方法，多加一个boole...
代码随想录算法训练营第二十二天| 491. 递增子序列、46. 全排列、47. 全排列Ⅱ
weixin_43831376的博客
09-09 823
第一题是去重的不同，去重时注意所给数据是否有序，有序的话就可以使用 Leetcode. 90 的去重思想；无序的话就需要其他容器记录已使用元素。排列问题要求结果有序，所以每次遍历都需要从头开始，并且需要一个容器记录哪些元素被使用过，注意这里的标识不是为了去重，而是为了调整结果顺序。去重和判断元素使用情况的区别，从Leetcode. 47 就可以看出来了。
leetcode题库-nowcoder-leetcode:编程题题解：牛客网&leetcode力扣（更新中...）
06-29
leetcode题库 原题链接
Python算法题源代码-LeetCode(力扣)-全排列
02-26
力扣热题Python源代码 题目46. 全排列 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1...
c++-c++编程基础之leetcode题解第46题全排列.zip
04-08
在C++编程中，LeetCode是一个非常受欢迎的在线平台，用于练习和提升算法与数据结构技能。本资源包聚焦于LeetCode的第46题，名为"全排列"（Permutations）。这道题目要求我们找到所有可能的排列方式，对于一个给定的...
C语言入门-leetcode练习之第47题全排列II.zip
05-26
在本压缩包中，我们关注的是C语言的学习以及在编程挑战平台LeetCode上的一个问题——第47题“全排列II”。这是一个经典的计算机科学问题，它涉及到数组操作、回溯算法和递归等核心编程概念。下面我们将深入探讨这些...
代码随想录算法训练营Day22 | 491.递增子序列，46.全排列，47.全排列 II ，332. 重新安排行程，51. N皇后，37. 解数独，总结
little__penguin的博客
07-07 433
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 489
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 285
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1174
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 314
试除法求约数、约数个数、约数之和、最大公约数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拉依达的嵌入式小屋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值