力扣刷题||L491.递增子序列、L46.全排列、L47.全排列 II

491. 递增子序列 - 力扣（LeetCode）

本题一开始自己审题不清楚，误以为需要对数组进行排序之后再考虑递增即可，谁知道原来是在一开始的基础上，考虑是否递增。

解题思路：

1、设立一个结果数组result和一个中间结果存储数组path。

 vector<vector<int>> result;//结果数组
 vector<int> path;//中间变量数组

2、写回溯的终止条件，根据题目要求因为至少要两个元素，故要求path的大小大于1即可

因为回溯的过程可以抽象为树形结构，很明显，本轮数层结构中不能有重复的值

在这在每层开始的前提，设立一个set容器，在每层搜索一个数的时候，判断此数是否在每层中出现过，若出现过，则跳过，避免重复，并且因为是要递增，故每个数必须大于path的最后一个数，这样才能满足条件，但是第一个数不满足此条件，故需要判断path是否为空。

3、然后就是将每层遍历的数插入set容器中，开始进行回溯。在这每个回溯的起始位置是i+1，因为是排列，故当前以及之前的数都不要考虑。

整体代码如下：

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);
            // 注意这里不要加return，要取树上的节点
        }
        unordered_set<int> uset; // 使用set对本层元素进行去重
        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;
    }
};

46. 全排列 - 力扣（LeetCode）

解题思路：

有了前题的基础，对与本题就好求解了，因为题意中是无重复数组，我们只需要考虑在数型方面的不重复。

在回溯对每层的每个数判断时，应该判断该数是否在之前进行树形的时候使用过，在这采用一个全局set数组，对每层每个使用过的数，将其插入，然后再每层开始之前，判断当前数是否在set中出现过，若出现过说明不能使用，则会导致后面重复。

并且每层开始的值，应该从0开始，而不用再传入startIndex.

class Solution {
private:
    vector<vector<int>>result;
    vector<int>path;
    unordered_set<int>uset;
    void backtracking(vector<int>& nums, unordered_set<int>uset)
    {
        if (path.size() == nums.size())
        {
            result.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++)
        {
            if (uset.find(nums[i])!=uset.end())//本层的东西不能选用
            {
                continue;//如果当前值不等于传进来的值，那就进行一步操作
            }
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums,uset);
            uset.erase(nums[i]);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> permute(vector<int>& nums) {
        backtracking(nums,uset);
        return result;
    }
};

再看过卡哥的代码后，发现可以用一个nums,size()大小的used的bool类型数组来判断之前的值是否使用过，如果使用过将其设为true，判断若为true就跳过。

for (int i = 0; i < nums.size(); i++) {
            if (used[i] == true) continue; // path里已经收录的元素，直接跳过
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }

47. 全排列 II - 力扣（LeetCode）

解题思路，本题来说也可以采用uset的方式，因为有重复的数组，既要判断树形的重复也要判断数层的重复，一开始自己采用了一个bool类型的used数组和对每层的uset容器进行判断，条件为：

   for (int i = 0; i < nums.size(); i++)
        {
            if (used[i] == true||( used[i] == false && (uset.find(nums[i])!=uset.end())))
            {
                continue;
            }
            used[i] = true;
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums, used);
            used[i] = false;
            path.pop_back();
        }

但是发现使用空间和计算时间会很长，后面发现卡哥是用回了之前的组合综合II的判断，先对数组进行排序，然后采用一个used数组进行判断，数层的重复

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }

在判断完数层重复之后，再判断树形重复，就是used[i]==false;

然后在这，我认为先判断数层重复再判断树形重复，这样较好，因为方便代码编写。

我再考虑是否可以先判断树形重复，好像也是可以的，判断当前used[i]是否等于true，说明当前值在使用中，若当前值等于前一个值，说明重复。