刷题记录回溯算法-14：491. 非递减子序列

原创已于 2025-01-19 20:58:37 修改 · 676 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #python #数据结构

于 2025-01-15 12:16:21 首次发布

刷题笔记专栏收录该内容

107 篇文章

订阅专栏

题目：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

一、模式识别

1.子集问题

子集问题是边访问边收集结果，

不仅在回溯树叶节点收集结果，

因此return和收集结果命令不在一起

2.搜索集

单独搜索集，

无重复选取，但可能含有重复元素

终止条件是最简单的访问到终点

3.结果收集条件

结果收集比较特殊，

需要递增序列

且至少两个元素

递增序列可以在实现路径过程中形成，不需要写在结果收集条件中

因此有在结果收集条件体现只少两个元素：

if len(path) >= 2:
    ans.append(path[:])

在path形成过程中剪去非递增的路径（并配合同层去重）：

if (path and ch < path[-1]) or ch in uset:
    continue

二.代码实现

本题只能基于数值哈希去重

used数值集合(set)：

class Solution:
    def backtracking(self, nums, start_idx, path, ans):
        if len(path) >= 2:
            ans.append(path[:])
        if start_idx == len(nums):
            return
        
        uset = set()
        for i in range(start_idx, len(nums)):
            ch = nums[i]
            if (path and ch < path[-1]) or ch in uset:
                continue
            path.append(nums[i])
            uset.add(ch)
            self.backtracking(nums, i + 1, path, ans)
            path.pop()
        
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        ans = []
        # nums.sort()
        self.backtracking(nums, 0, [], ans)
        return ans

used数值数组(list)：

class Solution:
    def backtracking(self, nums, start_idx, path, ans):
        if len(path) >= 2:
            ans.append(path[:])
        if start_idx == len(nums):
            return
        
        used = 201 * [False]
        for i in range(start_idx, len(nums)):
            ch = nums[i]
            if (path and ch < path[-1]) or used[ch + 100]:
                continue
            path.append(nums[i])
            used[ch + 100] = True
            self.backtracking(nums, i + 1, path, ans)
            path.pop()
        
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        ans = []
        # nums.sort()
        self.backtracking(nums, 0, [], ans)
        return ans