2021-11-7 491. 递增子序列（回溯+不排序去重）

注：

题目：
给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：
输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
示例 2：
输入：nums = [4,4,3,2,1]
输出：[[4,4]]

提示：
1 <= nums.length <= 15
-100 <= nums[i] <= 100

题解：
这个递增子序列比较像是取有序的子集。而且本题也要求不能有相同的递增子序列。

这又是子集，又是去重，是不是不由自主的想起了刚刚讲过的leetcode 90:求子集问题（二）。

就是因为太像了，更要注意差别所在，要不就掉坑里了！

leetcode 90:求子集问题（二） 中我们是通过排序，再加一个标记数组来达到去重的目的。

而本题求自增子序列，是不能对原数组经行排序的，排完序的数组都是自增子序列了。

所以不能使用之前的去重逻辑！

本题给出的示例，还是一个有序数组 [4, 6, 7, 7]，这更容易误导大家按照排序的思路去做了。

为了有鲜明的对比，我用[4, 7, 6, 7]这个数组来举例，抽象为树形结构如图：

同时还需要注意的是，本题需要收集所有的长度大于1的节点，而不是收集叶子结点。

复杂度分析
时间复杂度：O(2ⁿ * n)。仍然需要对子序列做二进制枚举，枚举出的序列虽然省去了判断合法性和哈希的过程，但是仍然需要 O(n) 的时间添加到答案中。
空间复杂度：O(n)。这里临时数组的空间代价是 O(n)，递归使用的栈空间的空间代价也是 O(n)。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums,int index){
        if(index>nums.size()){
            return ;
        }
        unordered_set<int> visited;
        for(int i=index;i<nums.size();i++){
            //这个元素在本层用过了，直接跳过该元素
            if(visited.find(nums[i])!=visited.end()){
                continue;
            }
            //不是递增序列，跳过该元素
            if(path.size()>0&&path[path.size()-1]>nums[i]){
                continue;
            }
            path.push_back(nums[i]);
            //记录本层使用过的元素，由于每层的visited都是新的，因此visited不需要回溯
            visited.insert(nums[i]);
            if(path.size()>1){
                result.push_back(path);
            }
            backtracking(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return result;
    }
};