Day25||* 491.递增子序列* 46.全排列* 47.全排列 II

最新推荐文章于 2024-09-02 16:50:54 发布

int WINGsssss

最新推荐文章于 2024-09-02 16:50:54 发布

阅读量90

点赞数

文章标签： leetcode 算法 c++ 数据结构 Powered by 金山文档

本文链接：https://blog.csdn.net/m0_63511417/article/details/129581652

版权

* 491.递增子序列

主要应该注意去重复的操作，对跳过元素的情况进行判定，要么是不符合递增序列要么是重复了。这里也可以用数组的哈希映射，因为序列的范围也比较合适。

class Solution
{

public:
vector<int> path;
vector<vector<int>> result;
    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> tmp;
        for(int i=index;i<nums.size();i++)
        {
            if(!path.empty()&&path.back()>nums[i]||tmp.find(nums[i])!=tmp.end())
            continue;

            path.push_back(nums[i]);
            tmp.insert(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }

    }
};

46.全排列

排列问题和组合问题最大的区别是不需要index，因为我们所有元素都要取一遍，所以是可以取到之前的元素的。

class Solution {
public:
vector<int> path;
vector<vector<int>> result;

    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        backtracking(used,nums);
        return result;

    }
    void backtracking(vector<bool> &used,vector<int> nums)
    {
        if(path.size()==nums.size())
        {
            result.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++)
        {
            if(used[i]==true)
            continue;

            used[i]=true;
            path.push_back(nums[i]);
            backtracking(used,nums);
            path.pop_back();
            used[i]=false;
        }

    }
};

47.全排列 II

其实这个题很特殊，去重的时候无论是同层去重还是枝干去重都可以，但是枝干去重复会做很多无用的搜索，而且很抽象，不本质含义是只能倒着排列相同元素，所以就达到了去重复的目的。所以正着排列相同的元素都会被试错。但是同层去重是保证只能正着去排列相同元素和我们的遍历方向一致的。

class Solution {
public:
vector<int> path;
vector<vector<int>> result;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        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(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;
            }
        }

    }
};