代码随想录算法训练营第二十五天|leetcode46、47、491题

最新推荐文章于 2026-01-08 22:28:34 发布

原创最新推荐文章于 2026-01-08 22:28:34 发布 · 379 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#算法

本文详细介绍了如何使用递归和回溯方法解决LeetCode中的第491题（递增子序列）、第46题（全排列）和第47题（去重全排列），重点讲解了处理数组排序和重复元素的策略。

一、leetcode第491题

本题要找不少于两个元素的递增子序列，这里运用回溯和递归结合的方法，但是由于数组不是按递增或递减的顺序排列，因此在去重方面略有不同，需要记录同一个父结点的子结点的值是否相同，如果相同则需要跳过，否则就不满足递增的条件。

具体代码如下：

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

    }
};

二、leetcode第46题

本题要求数组的全排列，通过构建树的方式发现这里要对树枝的元素进行标记，一个结点的元素值不能在其子结点中重复出现，这里用used数组在树枝遍历过程中进行标记。

具体代码如下：

class Solution {
public:
    vector<vector<int>>result;
    vector<int>path;
    vector<vector<int>> permute(vector<int>& nums) {
    vector<bool>used(nums.size(),false);
    backtracking(nums,used);
    return 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]==false)
            {
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            used[i]=false;
            path.pop_back();
            }
        }
    }
};

三、leetcode第47题

本题与上一题的不同在于数组中包含重复数字但是给出的全排列不能重复，这就要在上一题的基础上加入去重操作，首先将数组按升序排列，而后再新建一个used2数组进行结点值是否使用的标记，对树层进行去重，最后得到的结果就不会含有重复的子集。

具体代码如下：

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