算法力扣刷题记录 八十【491.递增子序列】

前言

回溯章节第10篇。记录 八十【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

---

二、尝试实现

2.1分析题目，确定方法

1. 题目的含义可以通过示例体会。首先nums中元素序列不能改变，也就是说不能重新排序。从示例1的输出，可以发现这是在一个集合中穷举所有可能的情况。穷举方式，在一个集合，选择组合——回溯方法。
2. 因为nums有重复元素，需要考虑去重。但是nums不能重新排序，考虑用别的方式去重。使用过去重的题目有：

• 记录 七十八【90.子集II】中练习用used数组去重，但是学习到用unordered_set去重，用unordered_set时不用排序。
• 记录 六十七【40.组合总和II】中主讲用used数组去重，但是nums要排序。

3. 所以：回溯实现+unordered_set去重方法。
4. 树形结构：
   

2.2思路

1. 用全局变量vector<vector< int>> result;放最后结果。vector temp;放中间搜集的结果。
2. 递归函数返回值：void。
3. 递归函数参数：

• int startindex选择组合应该从该元素的后面开始选取；
• vector< int >& nums传入的数组。

4. 递归终止条件：题目说子序列至少2个元素，所以temp.size() > 1，应该result.push_back(temp)。另外startindex在for循环的判断中实现终止控制。
5. 递归逻辑：

• for循环：i 从startindex开始，到nums.size()结束；
• 用去重逻辑：每一次递归都新建一个unordered_set。
  • 如果nums[i]在unordered_set中存在，说明该层已经选过重复的元素。无需再重复选。
• 递增控制：如果nums[i] < temp最后一个元素，说明不递增，所以continue。
• 处理节点：把nums[i]放入temp，再把nums[i]放入unordered_set记录是否选过。
• 递到下一层：startindex从i+1开始；
• 回溯：把nums[i]从temp弹出。注意：unordered_set不需要取出。

2.3 代码实现【回溯】

class Solution {
public:
    vector<vector<int>> result;
    vector<int> temp;
    void backtracking(int startindex,vector<int>& nums){
        unordered_set<int> set;//用unordered_set作去重
        if(temp.size() > 1) result.push_back(temp);//搜集所有的递增子序列

        for(int i = startindex;i < nums.size();i++){
            //递增序列控制,不递增，则跳过
            if(!temp.empty() && nums[i] < temp[temp.size()-1]) continue;
            //用set做去重
            if(set.find(nums[i]) != set.end()) continue;

            temp.push_back(nums[i]);
            set.insert(nums[i]);
            backtracking(i+1,nums);
            temp.pop_back();
        }
        return;
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        temp.clear();
        backtracking(0,nums);
        return result;
    }
};

---

三、参考学习

【491.递增子序列】 参考学习链接

学习内容

1. 参考思路和代码实现和二、中的分析一致。此处分析一下时间复杂度。时间复杂度=递归次数 * 每次递归的时间复杂度。每次递归都有一个for循环，for循环的时间复杂度是O(n)；递归次数：所以子集都是递增子序列，那么递归次数最多是2ⁿ。所以整体的时间复杂度是O(n * 2ⁿ)。
2. 分析一下空间复杂度。空间复杂度=递归深度 * 每次递归新开辟的空间。每次递归需要新开辟unordered_set空间，最大的大小是n。递归深度 = n。所以空间复杂度应该是O(n²)。
3. 优化方式：用数组代替unordered_set，来判断是否本层元素有重复使用。因为unordered_set的底层实现是哈希表，所以比数组复杂，数组的效率更高。
4. 优化代码改进：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> temp;
    void backtracking(int startindex,vector<int>& nums){
        bool used[201] = {false};//用数组作去重,true代表使用过。
        if(temp.size() > 1) result.push_back(temp);//搜集所有的递增子序列

        for(int i = startindex;i < nums.size();i++){
            //递增序列控制,不递增，则跳过
            if(!temp.empty() && nums[i] < temp[temp.size()-1]) continue;
            //用set做去重
            if(used[nums[i]+100]) continue;

            temp.push_back(nums[i]);
            used[nums[i]+100] = true;
            backtracking(i+1,nums);
            temp.pop_back();
        }
        return;
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        temp.clear();
        backtracking(0,nums);
        return result;
    }
};

---

总结

（欢迎指正，转载标明出处）