回溯算法：递增子序列，弄清去重本质！

回溯算法：递增子序列，去重从此不再困难！

思路：第一感觉和之前去重不是一样嘛？恭喜你上当了！
输入：[1,2,3,4,5,6,7,8,9,10,1,1,1,1,1]会发现[1,1],[1,1,1],[1,1,1,1],[1,1,1,1,1]重复出现了两次，问题就显现了，因为：之前去重是单层节点相邻元素之间的去重，因此，排序后去重if(i > startIndex && nums[i] == nums[i - 1])，但是现在我们不能将其进行排序，所有我们要采用第二种方法去重：去除同一层节点中的重复元素
代码如下：

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        int startIndex = 0;
        backtrack(nums, startIndex);
        return res;
    }
    void backtrack(vector<int>& nums, int startIndex)
    {
        //退出条件
        if(startIndex >= nums.size())
        {
            return;
        }
        // 使用set对本层元素进行去重
        unordered_set<int> uset; 
        for(int i = startIndex; i < nums.size(); i++)
        {
            //单层节点去重
            
            /*错误[1,2,3,4,5,6,7,8,9,10,1,1,1,1,1] 1没在一起，去重失败。
            if(i > startIndex && nums[i] == nums[i -1])
            {
                continue;
            }
            */
            //之前出现过了
            if(uset.find(nums[i]) != uset.end())
            {
                continue;
            }
            //插入set
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            if(path.size() >= 2 && isAdd(path))
            {
                res.push_back(path);
            }
            //递归进下一层
            backtrack(nums, i + 1);
            //回溯
            path.pop_back();
        }
    }
    bool isAdd(vector<int>& path)
    {
        if(path.size() <= 1)
        {
            return false;
        }
        bool result = true;
        for(int i = 1; i < path.size(); i++)
        {
            if(path[i] - path[i - 1] < 0)
            {
                result = false;
                break;
            }
        }
        return result;
    }
};