LeetCode 491：递增子序列 - 解构问题的智慧

前端

2023-10-27 13:16:31

摘要：

在本文中，我们将踏上一个激动人心的旅程，探索 LeetCode 491：递增子序列问题的巧妙本质。我们将深入了解问题的结构，发现优雅的解决方案，并掌握通往算法精通的途径。

问题的定义

给定一个整数数组 nums，我们的目标是找到并返回所有不相同的递增子序列，其中递增子序列至少包含两个元素。值得注意的是，数组中可能包含重复的元素。

解决方案的策略

要解决这个问题，我们可以采取两种主要方法：动态规划和回溯法。

动态规划

动态规划是一种自底向上的方法，它将问题分解成较小的子问题，并逐步解决这些子问题。在本文中，我们可以定义一个二维数组 dp，其中 dp[i][j] 表示以 nums[i] 结尾且长度为 j 的最长递增子序列。

回溯法

回溯法是一种自顶向下的方法，它通过尝试所有可能的路径，然后回溯无效的路径，来逐步构建解决方案。对于这个问题，我们可以递归地枚举所有可能的子序列，并检查它们是否满足递增条件。

代码示例

Python（动态规划）

def findSubsequences(nums):
    n = len(nums)
    dp = [[[] for _ in range(n+1)] for _ in range(n+1)]

    for i in range(n-1,-1,-1):
        for j in range(i+1):
            dp[i][j] = [(nums[i],)]
            for subsequence in dp[i+1][j]:
                if nums[i] <= subsequence[0]:
                    dp[i][j].append((nums[i],) + subsequence)
    
    return [list(subsequence) for subsequence in dp[0][0] if len(subsequence) > 1]

Python（回溯法）

def findSubsequences(nums):
    result = []
    path = []

    def backtrack(index):
        if index == len(nums):
            if len(path) > 1:
                result.append(path[:])
            return

        backtrack(index+1)
        if not path or path[-1] <= nums[index]:
            path.append(nums[index])
            backtrack(index+1)
            path.pop()
    
    backtrack(0)
    return result