LeetCode 491题解析：回溯算法解决非递减子序列问题-代码聚汇网

LeetCode 491题解析：回溯算法解决非递减子序列问题

chao wang

1. 题目解析与核心需求

Leetcode 491题"非递减子序列"是一道中等难度的回溯算法练习题。题目要求给定一个整数数组nums，找出所有不同的非递减子序列，子序列中至少有两个元素。这里的非递减指的是对于子序列中任意相邻的两个元素，后一个元素不小于前一个元素。

这道题的核心难点在于：

需要找到所有可能的子序列，而不是单一解
子序列需要满足非递减条件
需要避免重复的子序列出现在结果中
子序列长度至少为2

与简单的子集问题不同，这道题在回溯过程中需要额外处理顺序性和去重的问题，这也是它被归类为中等难度的原因。

2. 算法思路与设计考量

2.1 回溯算法选择

回溯算法是解决这类"找出所有可能解"问题的经典方法。对于子序列问题，回溯算法的优势在于：

可以系统地遍历所有可能的组合
通过剪枝优化减少不必要的计算
递归实现代码结构清晰

相比动态规划，回溯更适合这类需要列举所有解的问题，因为动态规划通常用于优化问题（如求最优解或计数）。

2.2 去重策略设计

本题的一个重要挑战是如何避免生成重复的子序列。例如对于输入[4,6,7,7]，[4,6]和[4,6]（来自不同的7）是重复的。

常见的去重方法有：

使用哈希表记录已生成的子序列
在回溯过程中通过条件判断跳过重复元素

方法1实现简单但空间复杂度高，方法2更高效但实现难度较大。对于本题，我们选择方法2，因为：

输入数组可能很大，哈希表消耗内存多
方法2可以在生成过程中即时去重，效率更高

2.3 非递减条件处理

在构建子序列时，我们需要确保每个新加入的元素不小于序列中最后一个元素。这可以通过在回溯的每一步进行条件判断来实现：

只有当当前数字≥序列末尾数字时才考虑加入
否则跳过该数字

这种剪枝策略可以显著减少不必要的递归调用。

3. 代码实现与详细解析

3.1 基础回溯框架

我们先构建一个基本的回溯框架：

python复制def findSubsequences(nums):
    result = []
    path = []
    
    def backtrack(start):
        if len(path) >= 2:
            result.append(path.copy())
        
        for i in range(start, len(nums)):
            # 选择nums[i]的条件判断
            path.append(nums[i])
            backtrack(i + 1)
            path.pop()
    
    backtrack(0)
    return result

这个基础版本还没有实现去重和非递减条件，但展示了回溯的基本结构：

path记录当前构建的子序列
result收集所有符合条件的子序列
backtrack函数通过递归探索所有可能选择

3.2 添加非递减条件

现在加入非递减条件的判断：

python复制def findSubsequences(nums):
    result = []
    path = []
    
    def backtrack(start):
        if len(path) >= 2:
            result.append(path.copy())
        
        for i in range(start, len(nums)):
            # 非递减条件：当前数字≥path最后一个元素
            if path and nums[i] < path[-1]:
                continue
            path.append(nums[i])
            backtrack(i + 1)
            path.pop()
    
    backtrack(0)
    return result

关键修改：

添加了if path and nums[i] < path[-1]: continue判断
只有当当前数字≥序列末尾数字时才继续处理

3.3 实现高效去重

最后加入去重逻辑。我们需要确保在同一层级不选择相同的数字：

python复制def findSubsequences(nums):
    result = []
    path = []
    
    def backtrack(start):
        if len(path) >= 2:
            result.append(path.copy())
        
        used = set()  # 记录本层使用过的数字
        for i in range(start, len(nums)):
            # 非递减条件
            if path and nums[i] < path[-1]:
                continue
            # 去重条件
            if nums[i] in used:
                continue
                
            used.add(nums[i])
            path.append(nums[i])
            backtrack(i + 1)
            path.pop()
    
    backtrack(0)
    return result

关键点：

引入used集合记录当前层级已使用的数字
如果当前数字已经在used中，则跳过
注意used是函数内的局部变量，只影响当前递归层级

3.4 完整代码实现

综合以上改进，得到最终解法：

python复制def findSubsequences(nums):
    result = []
    path = []
    
    def backtrack(start):
        if len(path) >= 2:
            result.append(path.copy())
        
        used = set()
        for i in range(start, len(nums)):
            # 非递减条件
            if path and nums[i] < path[-1]:
                continue
            # 去重条件
            if nums[i] in used:
                continue
                
            used.add(nums[i])
            path.append(nums[i])
            backtrack(i + 1)
            path.pop()
    
    backtrack(0)
    return result

4. 复杂度分析与优化空间

4.1 时间复杂度

最坏情况下，时间复杂度为O(2^n)，其中n是数组长度。这是因为：

每个元素都有选或不选两种可能
虽然有剪枝，但最坏情况下仍可能接近所有子集

实际运行时间会因剪枝而优于理论最坏情况。

4.2 空间复杂度

空间复杂度主要来自：

递归调用栈：O(n)
存储结果：O(n*2^n)（最坏情况下）

可以通过以下方式优化空间：

使用生成器而非列表存储结果（如果题目允许）
复用部分数据结构

4.3 可能的优化方向

迭代实现：可以尝试用栈模拟递归，减少函数调用开销
位运算枚举：对于小规模数据，可以用位掩码枚举所有子序列
并行处理：将问题分解为独立子问题并行计算

5. 常见问题与调试技巧

5.1 为什么我的结果包含重复子序列？

可能原因：

忘记在同一层级去重（缺少used集合）
去重逻辑放在了错误的位置（应该在选择数字前判断）

解决方案：

确保used集合是函数内局部变量
去重判断应在添加元素到path之前

5.2 为什么有些有效子序列没有被包含？