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

491.递增子序列 题目链接

思路

题目要求：“该数组中递增子序列”，所以不能排序。

解题方法

递归函数：

参数：数组，遍历起始下标

终止条件：当i>=nums.size()时

单层搜索逻辑：注意树层去重，同一父节点下的同层使用过的元素就不能再使用了

Code

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++){
            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) {
        result.clear();
        path.clear();
        backtracking(nums,0);
        return result;

    }
};

复杂度

时间复杂度:

O(n*2^n)

空间复杂度:

O(n)

46.全排列  题目链接

思路

 不需要设置startIndex来避免相等的元素重复取了

解题方法

定义一个bool的used数组,来记录哪些元素已经取过了，避免重复取同一个元素。

Code

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

    }
};

时间复杂度:

O(n！)

空间复杂度:

O(n)

47.全排列 II 题目链接

思路

题目描述“包含重复数字”“不重复的全排列”，意思是要求去重

使用bool的used来避免取到值相同的元素

解题方法

used来避免树层取到值相同的元素

Code

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(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;
            }

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

    }
};

时间复杂度:

O(n!*n)

空间复杂度:

O(n)