代码随想录算法训练营Day25 | Leetcode 491 非递减子序列 Leetcode 46 全排列 Leetcode 47 全排列Ⅱ

 Leetcode 491 非递减子序列

题目链接：491. 非递减子序列 - 力扣（LeetCode）

代码随想录题解：代码随想录 (programmercarl.com)

思路：这个题目也是不能重复用，那么为什么不能用used数组？因为这个题目不允许将原数组排序，所以必须用set

代码：

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

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

 Leetcode 46 全排列

题目链接：46. 全排列 - 力扣（LeetCode）

代码随想录题解：代码随想录 (programmercarl.com)

思路：排列问题不需要index，因为其中的元素还需要重复取。

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

    }
    return;

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

Leetcode 47 全排列Ⅱ

题目链接：47. 全排列 II - 力扣（LeetCode）

代码随想录题解：代码随想录 (programmercarl.com)

思路：这道题里面数组是可以有重复元素的，也就是不仅要避免树枝上的重复元素不能被选，还要保证同一树层的元素不能重复被选

代码：

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);
            path.pop_back();
            used[i]=false;
           }
        }
        return;
    }
    
    vector<vector<int>> permuteUnique(vector<int>& nums) {
    sort(nums.begin(),nums.end());
    vector<bool>used(nums.size(),false);
    backtracking(nums, used);
    return res;
    }
};