( 回溯算法) 491. 递增子序列 ——【Leetcode每日一题】

❓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

💡思路：回溯

本题可以使用回溯求解，可以将本问题切割成很多个小部分，只考虑其中一个数，然后将剩余的数往下递归处理，可以理解成好多层，每层只加一个元素：

• 定义一个数组 tmp 保存递增子序列，由于递增子序列中 至少有两个元素，所以只要递增子序列的长度如果大于 1 ,则是一种可能；
• 还要考虑去重的情况，可以使用 哈希表 或者 使用数组（元素范围为[-100, 100]）保存进行去重，这里使用数组：
  • 新的一层 used 都会重新定义（清空），所以要知道 used 只负责本层！

🍁代码：(Java、C++)

Java

class Solution {
    private List<List<Integer>> ans = new ArrayList<>();
    private List<Integer> tmp = new ArrayList<>();
    private void backtracking(int[] nums, int startIndex){
        if(tmp.size() > 1){//如果长度大于1就是一种可能
            ans.add(new ArrayList<>(tmp));
        }
        int[] used = new int[201];//使用数组对本层元素进行去重
        for(int i = startIndex; i < nums.length; i++){
            if((!tmp.isEmpty() && nums[i] < tmp.get(tmp.size() - 1)) || (used[nums[i] + 100] == 1)){//排除较小的数和已经使用过的数
                continue;
            }
            used[nums[i] + 100] = 1;// 记录这个元素在本层用过了，本层后面不能再用了
            tmp.add(nums[i]);
            backtracking(nums, i + 1);
            tmp.remove(tmp.size() - 1);//回溯，弹出最后一个元素，继续遍历其他可能
        }
    }

    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums, 0);
        return ans;
    }
}

C++

class Solution {
private:
    vector<vector<int>> ans;
    vector<int> tmp;
    void backtracking(vector<int>& nums, int startIndex){
        if(tmp.size() > 1){//如果长度大于1就是一种可能
            ans.push_back(tmp);
        }
        int used[201] = {0}; //使用数组对本层元素进行去重
        for(int i = startIndex; i < nums.size(); i++){
            if((!tmp.empty() && nums[i] < tmp.back()) || used[nums[i] + 100] == 1){//排除较小的数和已经使用过的数
                continue;
            }
            used[nums[i] + 100] = 1;// 记录这个元素在本层用过了，本层后面不能再用了
            tmp.push_back(nums[i]);
            backtracking(nums, i + 1);
            tmp.pop_back();//回溯，弹出最后一个元素，继续遍历其他可能
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums, 0);
        return ans;
    }
};

🚀 运行结果：

🕔 复杂度分析：

• 时间复杂度：$O(n\ast 2^n)$，这里枚举所有子序列的时间代价是 $O(2^n)$，每次检测序列是否合法和获取哈希值的时间代价都是 $O(n)$，故渐近时间复杂度为 $O(n\ast 2^n)$。
• 空间复杂度：$O(n)$。

题目来源：力扣。

放弃一件事很容易，每天能坚持一件事一定很酷，一起每日一题吧！
关注我LeetCode主页 / CSDN—力扣专栏，每日更新！

注： 如有不足，欢迎指正！