第二十九天|491. 递增子序列 46. 全排列 47. 全排列 II

最新推荐文章于 2024-07-24 20:44:05 发布

212t

最新推荐文章于 2024-07-24 20:44:05 发布

阅读量26

点赞数

文章标签：哈希算法散列表算法

本文链接：https://blog.csdn.net/Taoerber/article/details/134288097

版权

文章介绍了使用递归回溯法解决的两个问题：寻找给定数组中的递增子序列和全排列，着重强调了去重策略，如使用哈希集合和布尔数组来优化解决方案。

摘要由CSDN通过智能技术生成

491. 递增子序列

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums,int startIndex){
        if(path.size()>1)res.push_back(path);
        unordered_set<int> hash;
        for(int i=startIndex;i<nums.size();i++){
            if(hash.find(nums[i])!=hash.end())continue;
            if(!path.empty()&&nums[i]<path.back())continue;
            path.push_back(nums[i]);
            hash.insert(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return res;
    }
};

与子集思维类似，但是要if(path.size()>1)才res.push_back(path);

同时每一层用hash去重。

46. 全排列

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

使用used数组在树枝上去重

47. 全排列 II

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums,vector<bool>& used){
        if(path.size()==nums.size()){
            res.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(i>0&&nums[i]==nums[i-1]&&used[i-1]==0)continue;
            if(used[i]==1)continue;
            path.push_back(nums[i]);
            used[i]=1;
            backtracking(nums,used);
            used[i]=0;
            path.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(),0);
        backtracking(nums,used);
        return  res;
    }
};

添加了一个树层去重

if(i>0&&nums[i]==nums[i-1]&&used[i-1]==0)continue;