最长递增子序列-力扣

• dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度
• 位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值 if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
• 每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1
• dp[i] 与 0 - i 的dp值有关，所以需要从前往后便利

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

上述动态规划的解法，其时间复杂度为O（N * N)，力扣进阶所要求的时间复杂度为O(NlogN)，需要使用贪心的思想来进行实现。
利用贪心的思想维护一个单调递增数组 d[i] ，表示长度为 i 的最长上升子序列的末尾元素的最小值，用 len 记录目前最长上升子序列的长度，起始时 len 为 1，d[1]=nums[0]；

• 遍历到新的 nums 数组元素，如果 nums[i] > dp[len]，将其加入到单调递增数组的 len + 1位置，此时单调递增的子序列长度变为 len + 1，其末尾元素为 nums[i]‘
• 如果 nums[i] < dp[len]， 那么在 维护的单调递增数组dp[i]中，使用 二分查找 来找到其位置，并更新 dp[pos + 1], 使更新后的序列，同样满足单调递增，这里采用二分查找，用来降低时间复杂度。
• 当单调递增子序列 dp[i] 中查找不到 nums[i] 的位置，那么说明这个序列的值都比 nums[i] 大，那么说明需要更新 dp[1] 的值。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size() + 1, 0);
        int len = 1;
        dp[len] = nums[0];
        for(int i = 1; i < nums.size(); i++){
            if(nums[i] > dp[len]){
                dp[++len] = nums[i];
            } else{
                int l = 1, r = len, pos = 0;
                while(l <= r){
                    int mid = l + (r - l) / 2;
                    if(dp[mid] < nums[i]){
                        pos = mid;
                        l = mid + 1;
                    }else{
                        r = mid - 1;
                    }
                }
                dp[pos + 1] = nums[i];
            }
        }
        return len;
    }
};