代码随想录算法训练营Day29 | 491.递增子序列 46.全排列 47.全排列 II-CSDN博客

本文链接：https://blog.csdn.net/qq_24817679/article/details/138450054

本文介绍了在LeetCode平台上解决的两个问题，491.递增子序列和46/47.全排列/全排列II，通过递归和回溯法实现，重点讲解了去重和路径收集的策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代码随想录算法训练营Day29 | 491.递增子序列 46.全排列 47.全排列 II

LeetCode 491.递增子序列

思路：
1.path.size()>1收集结果；
2.去重，在同一层不能有重复元素。
3.判断当前元素是否大于等于path的最后元素

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> uset;
        for(int i = startIndex; i<nums.size(); i++){
            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();
        }
    }

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

注意：

path收集后不能return，因为收集的是全路径

LeetCode 46.全排列

题目链接：LeetCode 46.全排列

思路：
1.used数组思路，如果用过，则跳过收集即可

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]==true) continue;
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            used[i] = false;
            path.pop_back();

        }
    }

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

注意：

终止条件为path==nums size

LeetCode 47.全排列 II

题目链接：LeetCode 47.全排列 II

思路：
1.去重思路

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]== false) continue;

            if(used[i] == false){
                path.push_back(nums[i]);
                used[i] = true;
                backtracking(nums, used);
                used[i] = false;
                path.pop_back();
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        path.clear();
        res.clear();
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtracking(nums, used);
        return res;
    }
};