Leetcode 300.最长递增子序列

1.题目描述

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

输入：nums = [0,1,0,3,2,3]
输出：4

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示：

• 1 <= nums.length <= 2500
• -10^4 <= nums[i] <= 10^4

2.思路分析

2.1 动态规划

1.确定dp数组以及下标含义

• dp[i] : 考虑前 i个元素，以第 i个数字结尾的最长上升子序列的长度，注意 nums[i] 必须被选取 。

2.确定状态转移方程

• 位置i的最长上升子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。
• dp[i] = max(dp[i], dp[j] + 1) for j in [0, i)

3.dp数组的初始化

• dp[i] 所有元素置 1，含义是每个元素都至少可以单独成为子序列，此时长度都为 1。

4.确定遍历顺序

• 前->后(循环外层:i 循环内层:j)

5.举例推导dp数组

• 输入：[0,1,0,3,2]，dp数组的变化如下：

2.2 贪心+二分查找

如果要使上升子序列尽可能的长，则需要让序列上升得尽可能慢，因此每次在上升子序列最后加上的那个数尽可能的小。

基于上述贪心的思路:

• 数组d[i]: 长度为 i的最长上升子序列的末尾元素的最小值
  • 即在数组 1,2,3,4,5,6中长度为3的上升子序列可以为 1,2,3也可以为 2,3,4等等但是d[3]=3，即子序列末尾元素最小为3。
• len: 目前最长上升子序列的长度
• 起始状态:len=1 d[1]=nums[0]

d[i]是关于 i单调递增的

  如果 d[j]≥d[i] 且 j < i，我们考虑从长度为 i 的最长上升子序列的末尾删除 i-j 个元素，那么这个序列长度变为 j ，且第 j 个元素 x（末尾元素）必然小于 d[i]，也就小于 d[j]。那么我们就找到了一个长度为 j 的最长上升子序列，并且末尾元素比 d[j]小，从而产生了矛盾。因此数组 d 的单调性得证。

根据 d 数组的单调性，可以使用二分查找寻找下标 i，优化时间复杂度。

整个算法流程为:

• 设当前已求出的最长上升子序列的长度为 len(初始时为 1)，从前往后遍历数组 nums，在遍历到

  nums[i] 时：

  • 如果 nums[i]>d[len] ，则直接加入到 d 数组末尾，并更新 len=len+1；
  • 否则，在 d 数组中二分查找，找到第一个比 nums[i] 小的数 d[k] ，并更新d[k+1]=nums[i]。

举个栗子说明这个过程: nums = [10,9,2,5,3,7,101,18]

3.代码实现

3.1 动态规划

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [1] * n
        for i in range(n):
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j] + 1)
        return max(dp)

复杂度分析:

• 时间复杂度：$O(n^2)$，其中 n 为数组 nums 的长度。
• 空间复杂度：O(n)，需要额外使用长度为 n的 dp数组。

3.2 贪心 + 二分查找

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        d = []
        for i in range(len(nums)):
            if not d or nums[i] > d[-1]:
                d.append(nums[i])
            else:  # 当前遍历的元素nums[i] ≤ d[-1],需要在数组d中找到第一个小于nums[i]的元素
                left, right = 0, len(d)
                while left < right:
                    mid = (left + right) // 2
                    if d[mid] >= nums[i]:
                        right = mid
                    else:
                        left = mid + 1
                d[left] = nums[i]
        return len(d)

复杂度分析:

• 时间复杂度：$O(nlogn)$，其中 n 为数组 nums 的长度。
• 空间复杂度：O(n)，需要额外使用长度为 n的 d数组。