最长递增子序列（动态规划、贪心+二分）

动态规划：

时间复杂度：O(n^2)
空间复杂度：O(n)

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {

        int n=nums.size();
        if(n==0)
            return 0;
        int dp[n];

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

        return *max_element(dp,dp+n);
    }
};

贪心+二分：
时间复杂度：O(n*logn)
空间复杂度：O(n)

/**
如果我们要使子序列尽可能的长，则需要让子序列上升得尽可能慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小
*/
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {

        int n=nums.size();
        if(n==0)
            return 0;
        
        int d[n+1],len=1;
        d[1]=nums[0];

        for(int i=0;i<n;i++){
            if(d[len]<nums[i]){
                d[++len]=nums[i];
            }else{
                int left=1,right=len,pos=0;//如果在d[n+1]数组中二分查找不到第一个比nums[i]小的数，说明d[n+1]中所有数字都比nums[i]大，此时要更新d[1]，所以将pos设为0
                while(left<=right){
                    int mid=(left+right)>>1;
                    if(d[mid]<nums[i]){
                        pos=mid;
                        left=mid+1;
                    }else{
                        right=mid-1;
                    }
                }
                d[pos+1]=nums[i];
            }
        }
        
        return len;
    }
};