300. 最长递增子序列【 力扣(LeetCode) 】

零、原题链接

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

提示：

1 <= nums.length <= 2500
-104 <= nums[i] <= 104

三、解题思路

3.1 动态规划

1. 基本思路：
     利用动态规划的思想，假设严格递增子序列 i 表示从第 i 元素开始的最长的严格递增子序列，则严格递增子序列 i 可以由 第 i 个元素 和 由第 i+1 到 n 的大于第 i 个元素的最长严格递增子序列构成，即 $f(i)=\underset{i<j<n\wedge nums[j]>nums[i]}{\max }(f(j))+1$
2. 具体思路：
   • 从后往前开始构建严格递增子序列 i ：
     • 遍历第 i+1 到 n 的最长严格递增子序列长度
       • 如果第 j 个元素大于第 i 个元素
         • 如果比当前长度长，则当前长度为 其长度 +1；
     • 判断严格递增子序列 i 是否是最长的，是则记录；
   • 返回最长长度。

3.2 贪心 + 二分

1. 基本思路：
     顾名思义，就是采用贪心算法，对于序列的元素 x ，替换序列 vec 中第一个大于他的元素，如果没有，就在序列 vec 后面补充该元素。
   • 替换序列 vec 中第一个大于他的元素的原因：这样做，可以保证序列 vec 从头到该元素可以构成一个新的严格递增子序列。相比于同等长度旧的子序列，替换元素后的子序列更具有变长的潜力。【只是潜力，不一定能构建更长的子序列】这样做对旧的严格递增子序列是没有影响的，可以考虑下面三种情况：
     • 替换的前面的元素，对于旧的子序列，长度不变，所以最长还是旧的，虽然序列的元素发生了变化；
     • 替换的最后一个元素，这样旧的子序列就换了，但是长度不变，不过最后一个元素变小了，相比旧的子序列，更容易构建出长的子序列。
     • 在末尾新增一个元素，因为旧的子序列不存在比他大的数，所以直接添加到末尾，可以构成更长的子序列。
2. 具体思路：
   • 遍历序列
     • 对于元素 x ，使用二分查找，找到序列 vec 中第一个大于他的元素
       • 如果存在，则替换；
       • 否则，在尾部新增该元素；

四、参考代码

4.1 动态规划

时间复杂度：$\mathrm{O}(n^2)$
空间复杂度：$\mathrm{O}(n)$

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(), 1);
        int ans = 1;

        for (int i = nums.size() - 2; i >= 0; i--) {
            for (int j = i + 1; j < nums.size(); j++) {
                if (nums[j] > nums[i]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            ans = max(ans, dp[i]);
        }

        return ans;
    }
};

4.2 贪心 + 二分

时间复杂度：$\mathrm{O}(nlogn)$
空间复杂度：$\mathrm{O}(n)$

class Solution {
public:
    vector<int> vec;
    int n;

    void change(const int& x) {
        int l = 0, r = n - 1;

        while (l <= r) {
            auto mid = (l + r) >> 1;

            if (vec[mid] < x) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }

        if (l < n)
            vec[l] = x;
        else
            vec[n++] = x;
    }

    int lengthOfLIS(vector<int>& nums) {
        vec = vector<int>(nums.size());
        n = 0;
        vec[n++] = nums[0];

        for (int i = 1; i < nums.size(); i++) {
            change(nums[i]);
        }

        return n;
    }
};