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

问题1：491. 递增子序列 - 力扣（LeetCode）

思路：题目给出了一个数组，要求从中找出单调递增的子序列，至少含有两个元素。首先该题是要求划分，所以参数包含传入数组和index，终值条件则当path的长度大于2及将元组加入result中；关键在于单层递归逻辑这，用一个if语句，对前后两个连续的元素进行比较，同时该点处于树层，用一个set判断重复元素，具体代码如下：

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

问题2：46. 全排列 - 力扣（LeetCode）

思路：定义一个used，若数组中的元素被使用了则为false，结束该层循环加入下一层即可。代码如下：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtrack(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]==true) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtrack(nums,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(),0);
        result.clear();
        backtrack(nums,used);
        return result;
    }
};

问题3：47. 全排列 II - 力扣（LeetCode）

思路：该题给出的数组中包含重复元素，若按上一题的方法进行遍历则会出现重复元素，因此先对其进行排序，然后再多定义一个used2，若元素重复在树枝上出现则结束该次循环，具体代码如下：

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