贪心+二分查找

• 贪心：上升子序列尽可能长，序列上升尽可能慢，每次在上升子序列后加上的那个数尽可能小
• 数组d，长度为len的最长上升子序列，d[i]为长度为i的最长上升子序列的末尾元素最小值，起始len=1，d[1]=nums[0]
• 数组d是递增的
• 遍历nums，更新d和len
• 若nums[j]>d[len]，则len=len+1,d[len+1]=nums[j]
• 否则，在d[1…len]中找满足d[i-1]<nums[j]<d[i]的下标i，并更新d[i]=nums[j]
• 因为d是递增的，可以二分查找找到d中从右到左第一个比nums[j]小的下标pos，并更新d[pos+1]=nums[j]
• 示例 [0,8,4,12,2,5,6]
• len=1 d=[0]
• len=2 d=[0,8]
• len=2 d=[0,4]
• len=3 d=[0,4,12]
• len=3 d=[0,2,12]
• len=3 d=[0,2,5]
• len=4 d=[0,2,5,6]
• 最终的d=[0,2,5,6]，len为4

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