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
 

提示：

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

进阶：

你可以设计时间复杂度为 O(n2) 的解决方案吗？
你能将算法的时间复杂度降低到 O(n log(n)) 吗?

解答

dp[i]表示以nums[i]结尾的最长递增子序列大小。

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

二分+dp思路

/*
q[i] 表示长度为i+1的最长上升子序列，结尾最小是多少。
q[i] 是严格单调递增的。
对于当前数x，在q里二分出第一个大于等于x的q[i]， q[i] = x;
*/

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int tt = 0;
        vector<int> q(nums.size());
        for (auto x : nums)
        {
            if (!tt || x > q[tt - 1]) q[tt++] = x;//!tt就是为空，tt-1就是q的back，tt就是当前最长递增子序列的长度，如果大于back就会加1。
            else
            {
                int l = 0, r = tt - 1;
                while (l < r)
                {
                    int mid = l + r >> 1;
                    if (q[mid] >= x) r = mid;//判定落点
                    else l = mid + 1;
                }
                q[r] = x;//寻找插入位置。
            }
        }
        return tt;
    }
};

举个例子[5,6,3,4,2],q和tt依次是

[5] tt=1
[5,6] tt=2
[3,6] tt=2
[3,4] tt=2
[2,4] tt=2

对于[5,6]来说，表示长度为1的最长递增子序列(下面简称LIS)的最后一个元素最小是5，而长度为2的LIS最后一个元素最小是6。对于[3,6]，表示长度为1的LIS最后一个元素最小是3，很对。一定要这样理清楚，否则都是瞎搞。

相当于贪心填鸭，尽量找出最小的满足给定长度LIS的元素。

利用库函数

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int res=0;
        vector<int> dp;
        for(auto x: nums){
            int idx=lower_bound(dp.begin(),dp.end(),x)-dp.begin();//[10,10,20]找20idx结果是2
            if(idx>=dp.size())dp.push_back(x);//当idx=dp.size()的时候意味着在末尾加入
            else dp[idx]=x;
        }
        return dp.size();
    }
};

这里利用了一手lower_bound找不到返回last迭代器，减去begin迭代器刚好是dp.size()。

more details

本题还可以使用二分查找将时间复杂度降低为 O(n log n)。我们定义一个 dp 数组，其中 dp[k] 存储长度为 k+1 的最长递增子序列的最后一个数字。我们遍历每一个位置 i，如果其对应的数字 大于 dp 数组中所有数字的值，那么我们把它放在 dp 数组尾部，表示最长递增子序列长度加 1； 如果我们发现这个数字在 dp 数组中比数字 a 大、比数字 b 小，则我们将 b 更新为此数字，使得 之后构成递增序列的可能性增大。以这种方式维护的 dp 数组永远是递增的，因此可以用二分查找加速搜索。

相当于单调递增的栈。算是用数据结构优化的动态规划。但这里还用了一个更牛的技巧，就是不去弾栈，而是直接去原地更新，脑子里没有想那个栈。直接二分可以降低很大的复杂度。也许在一般的单调栈里面也可以这样做。

以样例为例，对于数组 [10,9,2,5,3,7,101,18]，我们每轮的更新查找情况为：

num     dp
10      [10]
9       [9]
2       [2]
5       [2,5]
3       [2,3]
7       [2,3,7]
101     [2,3,7,101]
18      [2,3,7,18]

最终我们就获得了 [2,3,7,18] 这个最长递增数组之一。该算法的代码实现如下。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if(n<=1) return n;
        vector<int> dp;
        dp.push_back(nums[0]);
        for(int i=1;i<n;i++)//has pushed nums[0]
        {
            if(dp.back()<nums[i])dp.push_back(nums[i]);
            else{
                auto iter = lower_bound(begin(dp),end(dp),nums[i]);
                *iter = nums[i];
            }
        }
        return dp.size();
    }
};