300. **Longest Increasing Subsequence (最长递增子序列)

300. **Longest Increasing Subsequence (最长递增子序列)

https://leetcode.com/problems/longest-increasing-subsequence/description/

题目描述

Given an integer array nums, return the length of the longest strictly increasing subsequence.

A subsequence is a sequence that can be derived from an array by deleting some or no elements without changing the order of the remaining elements. For example, [3,6,2,7] is a subsequence of the array [0,3,1,6,2,2,7].

Example 1:

Input: nums = [10,9,2,5,3,7,101,18]
Output: 4
Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.

Example 2:

Input: nums = [0,1,0,3,2,3]
Output: 4

Example 3:

Input: nums = [7,7,7,7,7,7,7]
Output: 1

Constraints:

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

Follow up:

• Could you come up with the O(n^2) solution?
• Could you improve it to O(n log(n)) time complexity?

代码实现

给定一个未排序的整数数组, 将其中最长递增子序列的长度求出来. 这道最长递增子序列印象很深刻~ 首先考虑使用动态规划来进行求解. 定义 dp[i] 表示以 nums[i] 结尾的数组中最长递增子序列的长度. 注意这个定义中说的 “以 nums[i] 结尾”. 为了得到状态转移方程, 需要考察 dp[i] 和其他元素的关系. 我们发现, 对于 j < i,

• 如果 nums[i] > nums[j], 那么就可以在 dp[j] 对应的最长递增子序列末尾, 将 nums[i] 插入, 此时仍满足递增的性质, 这时候有 dp[i] = dp[j] + 1 (nums[i] > nums[j]);
• 而如果 nums[i] <= nums[j], 说明 nums[i] 无法加入到 dp[j] 对应的最长递增子序列中, 又因为对于 dp[i] 的定义中说的是需要 “以 nums[i] 结尾”, 那么 dp[i] = 1, 表示此时以 nums[i] 结尾的数组中的最长递增子序列其实就是 nums[i] 本身, 大小为 1. (因此, dp 初始化时, 元素均设置为 1 很方便)

归纳上面的分析, 可以得到状态转移方程为:

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

因此代码如下:

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
    	int res = 0;
        vector<int> dp(nums.size(), 1);
        for (int i = 1; i < nums.size(); ++ i) {
            for (int j = i - 1; j >= 0; -- j) {
                if (nums[i] > nums[j])
                    dp[i] = max(dp[i], dp[j] + 1);
            }
            res = max(res, dp[i]);
        }
        
        return res;
    }
};

举个例子, 下面列出数组 nums 以及数组中每个元素对应的 dp 值:

nums: 4, 10, 4, 3, 8, 9
  dp: 1,  2, 1, 1, 2, 3

最后求出 dp 中最大值为 3, 即 LIS 长度为 3, 比如 3, 8, 9 或者 4, 8, 9.

这道题的 Follow up 中提到可以使用 O(n log(n)) 的复杂度求解. 思路是尝试将数组中的最长递增子序列给找出来. 具体方法是:

使用序列 r 来保存 nums 中的最长递增子序列. 遍历 nums 的每一个元素 v, 然后在数组 r 中找到 v 对应的 lower_bound, 即第一个大于或等于 v 的值.

• 如果在序列 r 中找不到 v, 说明 v 比 r 中的所有元素都大, 因此可以将 v 加入到 r 的末尾,
• 而如果 r 中存在某元素(代码中用 *p 表示)大于或等于 v, 那么用 v 将这个元素替换, 这样的话, 一方面, 如果 *p 原本就等于 v, 那么没任何影响; 而如果 *p 原本大于 v, 那么此时更新成 v 后, 相当于数值变小了, 以后插入新的元素, 有更多得机会使得序列增长.

代码如下:

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> r;
        
        for(auto v : nums) {
            auto p = std::lower_bound(r.begin(), r.end(), v);
            if (r.end() == p)
                r.push_back(v);
            else
                *p = v;
        }
        return r.size();
    }
};