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

day29 2023/03/01

一、递增子序列

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

分析如下：

我用[4, 7, 6, 7]这个数组来举例，抽象为树形结构如图：

 

代码如下：

注意：

使用set进行去重（并且注意去重的逻辑）

不要加return,因为要取树上的节点

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums,int startIndex)
    {
         if(path.size()>1)
         {
             result.push_back(path);
            // return;不能加return，因为要取树上的节点
         }
         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) {
        backtracking(nums,0);
        return result;
    }
};

二、全排列

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

分析如下：

抽象成树形结构如下：

代码如下：
 

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

三、全排列Ⅱ

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

分析如下：

抽象为一棵树，去重过程如图：

 

代码如下：

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