LeetCode 300. 最长递增子序列

300. 最长递增子序列

题目描述

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

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

示例 1：

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

示例 2：

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

示例 3：

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

进阶：

你能将算法的时间复杂度降低到 O(n log(n)) 吗?

解题思路

思路一： 动态规划

1. 状态定义
dp[i]表示以nums[i]结尾的最长上升子序列长度；

2. 转移方程
设 $j\in [0,i)$， 考虑到每轮计算新dp[i]时， 遍历[0, i)列表区间， 有以下两种：

• 当nums[i] > nums[j]时， nums[i]可以接在nums[j]之后， 此时最长上升子序列长度为dp[j] + 1;
• 否则， 此情况上升子序列不成立，跳过即可；
  得出转移方程： $dp[i]=max(dp[i],dp[j]+1)且nums[j]<nums[i]$

3. 初始状态
dp[i] 所有元素置为1，含义是每个元素都至少可以单独成为子序列；

4. 返回值
返回 dp 列表最大值，即可得到全局最长上升子序列长度

实现代码如下：

/**
 * @param {number[]} nums
 * @return {number}
 */
var lengthOfLIS = function(nums) {
    let len = nums.length,
        dp = Array(len).fill(1), 
        maxLen = 1;
    for (let i = 1; i < len; i++) {
        for (let j = 0; j < i; j++) {
            if (nums[i] > nums[j]) {
                dp[i] = Math.max(dp[i], dp[j] + 1);
            }
        }
        maxLen = Math.max(dp[i], maxLen);
    }
    return maxLen;
};

• 时间复杂度：$O(n^2)$ ，其中 n 为数组 nums 的长度。动态规划的状态数为 n，计算状态 dp[i] 时，需要 O(n) 的时间遍历 dp[0…i−1] 的所有状态

• 空间复杂度：O(n)

思路二：贪心 + 二分查找

1. 状态定义
tails[k] 的值代表 长度为 k+1 子序列 的尾部元素值。
注意: 数组 tail 不是问题中的「最长上升子序列」, 只是用于求解问题的状态数组

2. 转移方程
设 res 为 tails 当前长度，代表直到当前的最长上升子序列长度。
设 $j\in [0,res)$，考虑每轮遍历 nums[k] 时，通过二分法遍历 [0,res) 列表区间，找出 nums[k] 的大小分界点，会出现两种情况：

• 区间中存在 tails[i] > nums[k] ： 将第一个满足 tails[i] > nums[k] 执行 tails[i] = nums[k] ；因为更小的 nums[k] 后更可能接一个比它大的数字（即用它覆盖掉比它大的元素中最小的那个） ;
• 区间中不存在 tails[i] > nums[k] ： 意味着 nums[k] 可以接在前面所有长度的子序列之后，因此肯定是接到最长的后面（长度为 res ），新子序列长度为 res + 1;

3. 初始状态
令 tails 列表所有值 =0

4. 返回值
返回 res ，即最长上升子子序列长度。

/**
 * @param {number[]} nums
 * @return {number}
 */
var lengthOfLIS = function(nums) {
    let len = nums.length,
        tails = Array(len).fill(0), 
        res = 0;
    for (let num of nums) {
        let i = 0, j = res;
        while (i < j) {
            let m = (i + j) >> 1;
            if(tails[m] < num) i = m + 1;
            else j = m;
        }
        tails[i] = num;
        if(res == j) res++;
    } 
    return res;
};

• 时间复杂度：$O(nlogn)$ ，其中 n 为数组 nums 的长度。遍历 nums 列表需 O(n)，在每个 nums[i] 二分法需 O(logN)

• 空间复杂度：O(n)

参考资料

https://leetcode.cn/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-dong-tai-gui-hua-2/