力扣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数组的含义为：dp[i]是以i结尾的最长递增子序列的长度
对于每个新增位置来说，如果前面的数比他小，那以他结尾的递增子序列就是前面那个数+1
举例来说：对于 2，5，4
以2结尾，长度为1；
以5结尾，之前的2<5，递增子序列为2时的递增子序列+1
以4结尾，之前的2<4，递增子序列为2时的递增子序列+1
之前的5>4，对递增子序列无影响
通过两重循环，不断更新dp[i]，可得转移方程为
如果nums[j] < nums[i] 更新dp[i] = max(dp[i], dp[j] + 1)
最后找到dp中的最大值，即为答案

代码

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

思路（贪心+二分）

参考了官方题解的思路
如果我们要使上升子序列尽可能的长，则我们需要让序列上升得尽可能慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小。我们维护一个数组 d[i] ，表示长度为 i 的最长上升子序列的末尾元素的最小值，用ans记录目前最长上升子序列的长度，起始时为1，d[1] = nums[0]

可以这样理解，我要做的局部最优，就是给定子序列长度，其末尾元素最小；这样如果新来一个较大的数，则可以最大程度更新递增子序列的长度，则就是全局最优解。

举例来说，对于[10,9,2,5,3,7,101,18]，逐位遍历，维护d[i]，d[0]不用
第一步：插入10，长度为1，此时d = {0,10}
第二步：9比d[1]小，不能使递增子序列长度增加，但9比d[1]小，可以更新长度为1子序列的末尾最小值，此时d = {0,9}
第三步：2比d[1]小，同理第二步，更新d[1]，此时d = {0,2}，此时长度为1的递增子序列末尾最小值为2
第四步：5比d[1]大，可以加入d，增加递增子序列长度，此时d = {0,2,5}，如果前面没有更新d[1]=2，这里判断就会无法加入5
第五步：3比d[2]小，不能增加长度，但比d[1]大，可以更新长度为2的递增子序列末尾最小值为3，此时d = {0,2,3}
第六步：7比d[2]大，可以增加长度，d = {0,2,3,7}
第七步：101比d[3]大，可以增加长度，d = {0,2,3,7,101}
第八步：18比d[4]小，不能增加长度，但比d[3]大，可以更新长度为4的递增子序列末尾最小值为18，此时d = {0,2,3,7,18}

样例到此结束，最长递增子序列长度为4,虽然[2,3,7,101]，[2,3,7,18]长度都为4，但如果原序列再多一个元素25，此时最长递增子序列就应为[2,3,7,18,25]，因为本方法保证长度为4时末尾元素最小，则新增一个可增加递增子序列的元素时，必然能够加入，可以获得全局最优解。

证明利用反证法：对于长度为n的递增子序列，保证其是所有长度为n的递增子序列所有组合中末尾最小的那一组合。如果新增元素不能加入，但最大递增子序列长度为n+1；说明新增元素小于d[n]，任何其他递增子序列也都无法加入，与递增子序列矛盾。

算法实现上，对于d来说，是一个递增序列；而每次对于新加入元素x，在d的何处更新，则转化为二分查找问题，d[i]<x且d[i+1]>x就是x的归宿，同时还要加一条对x<d[1]更新d[1]的判断

代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int ans = 1;
        int n = nums.size();
        if(n == 0) return 0;
        vector<int> d(n+1, 0);
        d[1] = nums[0];
        for(int i = 1; i < n; i++) {
            if(nums[i] > d[ans]) {
                ans++;
                d[ans] = nums[i];
            }
            else {
                int l = 1, r = ans;
                while(l <= r) {
                    int mid = (l + r) >> 1;
                    if(nums[i] < d[1]) {
                        d[1] = nums[i];
                        break;
                    }
                    if(d[mid-1] < nums[i] && d[mid] > nums[i]) {
                        d[mid] = nums[i];
                        break;
                    }
                    else if(d[mid] < nums[i]) {
                        l = mid +1;
                    }
                    else r = mid - 1;
                }
            }
        }
        return ans;
    }
};