leetcode 491. 递增子序列 思考分析

题目

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

说明:
给定数组的长度不会超过15。
数组中的整数范围是 [-100,100]。
给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

思考

这一题和leetcode 90. 子集 II 思考分析的思想有点像。
但是需要注意的是：
1、该数组是求递增子序列，所以不能打乱原数组的顺序。
2、递增子序列
3、递增子序列的长度最少是2
其它的思想：回溯、去重其实和leetcode 90. 子集 II 思考分析是一样的。
对于上面两个问题，我们可以这也解决：
1、我们之前排序的是为了使相同的元素靠到一起，然后通过判断元素是否出现过来去重：

if(i > start && nums[i] == nums[i-1]) continue;

既然是判断元素是否出现过，那么我们就可以使用哈希法，注意这里判断的是解空间树本层是否出现重复元素，所以去重操作仍然是在for循环中：

unordered_set<int> set;
for(int i=start;i<end;i++)
{
    //如果在本层重复使用了某个元素，那么跳过
    if(set.find(nums[i])!=set.end()) continue;
    set.insert(nums[i]);
    //剩下的回溯代码
 }

2、递增序列如何判断：
只要在本层for循环中检查该元素是否大于子序列的最后一个元素即可：

//如果元素小于子序列的最后一个元素
if(res.size()>=1 && nums[i]<res[res.size()-1]) continue;

注意这个continue操作应该在上一个哈希法去重之前。
3、递增子序列的长度最少是2，在将res送入result之前先进行判断一下

if(res.size()>=2) result.push_back(res);

至此，我们这个问题就解决差不多了。
下面是整个代码：

代码

注意这里的floor是为了调试看层数的，所以可以不使用这个变量。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> res;
    int floor=0;
    void backtracking(vector<int>& nums,int start,int end)
    {
        if(res.size()>=2) result.push_back(res);
        //剩余集合为空，返回
        if(start>=end)
        {
            return;
        }
        unordered_set<int> set;
        for(int i=start;i<end;i++)
        {
            //如果元素小于子序列的最后一个元素
            if(res.size()>=1 && nums[i]<res[res.size()-1]) continue;
            //如果在本层重复使用了某个元素
            if(set.find(nums[i])!=set.end()) continue;
            set.insert(nums[i]);
            //cout<<nums[i]<<"层数："<<floor<<endl;
            //处理结点；
            res.push_back(nums[i]);
            floor++;
            //递归,探索下一层
            backtracking(nums,i+1,end);		//递归
            floor--;
            //回溯，撤销处理结果
            res.pop_back();
        }
        return;
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        res.clear();
        floor=0;
        backtracking(nums,0,nums.size());
        return result;
    }
};

优化

对于本层元素是否重复使用我们使用了set，题目中限定了数值范围[-100,100]所以可以用数组来做哈希表。
因为对set的insert操作需要做哈希映射相对耗费时间，并且每次重新定义set，insert的底层符号表也要做扩充。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> res;
    int floor=0;
    void backtracking(vector<int>& nums,int start,int end)
    {
        if(res.size()>=2) result.push_back(res);
        //剩余集合为空，返回
        if(start>=end)
        {
            return;
        }
        int usedArray[201]={0}; //这里使用数组来进行去重操作。
        for(int i=start;i<end;i++)
        {
            //如果元素小于子序列的最后一个元素
            if(res.size()>=1 && nums[i]<res[res.size()-1]) continue;
            //如果在本层重复使用了某个元素
            if(usedArray[nums[i]+100] ==1) continue;
            usedArray[nums[i]+100] =1;
            //cout<<nums[i]<<"层数："<<floor<<endl;
            //处理结点；
            res.push_back(nums[i]);
            floor++;
            //递归,探索下一层
            backtracking(nums,i+1,end);		//递归
            floor--;
            //回溯，撤销处理结果
            res.pop_back();
        }
        return;
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        res.clear();
        floor=0;
        backtracking(nums,0,nums.size());
        return result;
    }
};