代码随想录算法训练营第二十九天|491.递增子序列、46.全排列、47.全排列 II

LeetCode 491 递增子序列

题目链接：https://leetcode.cn/problems/non-decreasing-subsequences/

思路：

新的去重方式：使用unordered_set<int>uset来去重。因为每次递归都会重新创建一个uset的哈希表，所以对于uset不用进行回溯，它仅用于记录同一树层中使用过的元素。

代码：

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

    void backtracking(vector<int>&nums,int startindex)
    {
        if(path.size()>1)
            result.push_back(path);

        unordered_set<int>uset; // 用来记录本层递归使用过的元素
        for(int i = startindex;i<nums.size();i++)
        {
            // 两个去重条件：
            // 1、下一个数小于path里面最右边的数，此时为了使path.back()合法，要先判断path不为空
            // 2、在同一树层中，使用了相同元素
            if((!path.empty()&&nums[i]<path.back())||uset.find(nums[i])!=uset.end())
                continue;

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

public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        path.clear();
        result.clear();
        backtracking(nums,0);
        return result;
    }
};

总结

学习了新的去重方式。

LeetCode 46 全排列

题目链接：https://leetcode.cn/problems/permutations/

思路：

本题和组合、分割还有子集问题不一样的地方在于：[1,2,3]和[2,1,3]是两个不同的答案。所以排序问题不再需要startindex去限定for循环的起始位置，需要用used数组去记录使用过的下标。

代码：

• unordered_set回溯法

class Solution {
private:
    vector<vector<int>>result;
    vector<int>path;
    unordered_set<int>uset;
    
    void backtracking(vector<int>&nums,unordered_set<int>&uset)
    {
        if(path.size()==nums.size())
        {
            result.push_back(path);
            return ;
        }

        for(int i = 0;i<nums.size();i++)
        {
            if(uset.find(nums[i])!=uset.end())
                continue;

            path.push_back(nums[i]);
            uset.insert(nums[i]);
            backtracking(nums,uset);
            path.pop_back();
            uset.erase(nums[i]);
        }

    }

public:
    vector<vector<int>> permute(vector<int>& nums) {
        path.clear();
        result.clear();
        uset.clear();
        backtracking(nums,uset);
        return result;
    }
};

• used数组回溯法

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数组记录使用过的下标
            if(used[i]==true)
                continue;

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

    }

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

总结

学习了全排列问题，自己写出了unordered_set的回溯法。

LeetCode 47 全排列 II

题目链接：https://leetcode.cn/problems/permutations-ii/

思路：

要进行树层去重

代码：

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++)
        {
            if(used[i]||i>0&&nums[i]==nums[i-1]&&!used[i-1])
                continue;
            
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums,used);
            used[i] = false;
            path.pop_back();
        }

    }

public:
    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;
    }
};

总结

相对简单。

今日总结：

学习了新的去重方式：用unordered_set去进行去重，且不用回溯，每一层树层会新建一个unordered_set。学习了全排列问题。