LeetCode 300. 最长上升子序列（Python、动态规划、贪心算法）

学习动态规划和贪心算法的应用

题目描述

方法一：动态规划

思路与算法

定义 $dp[i]$ 为考虑前 $i$ 个元素，以第 $i$ 个数字结尾的最长上升子序列的长度，注意 $\text{nums}[i]$ 必须被选取。

我们从小到大计算 $dp[]$ 数组的值，在计算 $dp[i]$ 之前，我们已经计算出 $dp[0\dots i-1]$ 的值，则状态转移方程为：

$$dp[i]=\text{max}(dp[j])+1,\text{其中}0\le j<i\text{且}\text{num}[j]<\text{num}[i]$$

即考虑往 $dp[0\dots i-1]$ 中最长的上升子序列后面再加一个 $\text{nums}[i]$。由于 $dp[j]$ 代表 $\text{nums}[0\dots j]$ 中以 $\text{nums}[j]$ 结尾的最长上升子序列，所以如果能从 $dp[j]$ 这个状态转移过来，那么 $\text{nums}[i]$ 必然要大于 $\text{nums}[j]$，才能将 $\text{nums}[i]$ 放在 $\text{nums}[j]$ 后面以形成更长的上升子序列。

最后，整个数组的最长上升子序列即所有 $dp[i]$ 中的最大值。
$${\text{LIS}}_{\text{length}}=\text{max}(dp[i]),\text{其中}0\le i<n$$

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

复杂度分析

• 时间复杂度：$O(n^2)$，其中 $n$ 为数组 $\text{nums}$ 的长度。动态规划的状态数为 $n$，计算状态 $dp[i]$ 时，需要 $O(n)$ 的时间遍历 $dp[0\dots i-1]$ 的所有状态，所以总时间复杂度为 $O(n^2)$。
• 空间复杂度：$O(n)$，需要额外使用长度为 $n$ 的 $dp$ 数组。

方法二：贪心 + 二分查找

思路与算法

考虑一个简单的贪心，如果我们要使上升子序列尽可能的长，则我们需要让序列上升得尽可能慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小。

基于上面的贪心思路，我们维护一个数组 $d[i]$ ，表示长度为 $i$ 的最长上升子序列的末尾元素的最小值，用 $\text{len}$ 记录目前最长上升子序列的长度，起始时 $len$ 为 $1$，$d[1]=\text{nums}[0]$。

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

我们依次遍历数组 $\text{nums}[]$ 中的每个元素，并更新数组 $d[]$ 和 $len$ 的值。

• 如果 $\text{nums}[i]>d[\text{len}]$ 则更新 $len=len+1$，
• 否则在 $d[1\dots len]$中找满足 $d[i-1]<\text{nums}[j]<d[i]$ 的下标 $i$，并更新 $d[i]=\text{nums}[j]$。

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

最后整个算法流程为：

• 设当前已求出的最长上升子序列的长度为 $\text{len}$（初始时为 $1$），从前往后遍历数组 $\text{nums}$，在遍历到 $\text{nums}[i]$ 时：
  • 如果 $\text{nums}[i]>d[\text{len}]$ ，则直接加入到 $d$ 数组末尾，并更新 $\text{len}=\text{len}+1$；
  • 否则，在 $d$ 数组中二分查找，找到第一个比 $\text{nums}[i]$ 小的数 $d[k]$ ，并更新 $d[k+1]=\text{nums}[i]$。

以输入序列 $[0,8,4,12,2]$ 为例：

• 第一步插入 $0$，$d=[0]$；
• 第二步插入 $8$，$d=[0,8]$；
• 第三步插入 $4$，$d=[0,4]$；
• 第四步插入 $12$，$d=[0,4,12]$；
• 第五步插入 $2$，$d=[0,2,12]$。

最终得到最大递增子序列长度为 $3$。

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:
                loc = self.bisect(d, nums[i])
                d[loc] = nums[i]
        return len(d)

    def bisect(self, nums, k):
        left = 0
        right = len(nums) - 1
        loc = right
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] >= k:
                loc = mid
                right = mid - 1
            else:
                left = mid + 1
        return loc

复杂度分析

• 时间复杂度：$O(n\log n)$。数组 $\text{nums}$ 的长度为 $n$，我们依次用数组中的元素去更新 $d$ 数组，而更新 $d$ 数组时需要进行 $O(\log n)$ 的二分搜索，所以总时间复杂度为 $O(n\log n)$。
• 空间复杂度：$O(n)$，需要额外使用长度为 $n$ 的 $d$ 数组。