leetcode-300 Longest Increasing Subsequence

Longest Increasing Subsequence

LIS问题，这里给出两种解法：

方法1：普通DP O(n^2)

数组dp中保存该位置LIS的最大长度，首先全部置1，从前向后推，比较nums[i]和其之前元素nums[j]的大小，如大于则可以和j处计算得到的序列构成新的上升序列，长度加1.

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if(n==0)
            return 0;
        int dp[n];
        int MAX = 0;
        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);
            MAX = max(MAX, dp[i]);
        } 
        return MAX;      
    }
};

方法2：DP+二分搜索 O(nlogn)

定义d[k]:长度为k的上升子序列的最末元素，若有多个长度为k的上升子序列，则记录最小的那个最末元素。
注意d中元素是单调递增的，下面要用到这个性质。
首先len = 1,d[1] = a[1],然后对a[i]:若nums[i]>d[len]，那么len++，d[len] =nums[i];
否则，我们要从d[1]到d[len-1]中找到一个j，满足d[j-1]<a[i]<=d[j],则根据D的定义，我们需要更新长度为j的上升子序列的最末元素（使之为最小的）即 d[j] = a[i];（此时a[i]可以和前面j-1个元素构成长为j的上升序列）
最终答案就是len
利用d的单调性，在查找j的时候可以二分查找，从而时间复杂度为nlogn。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if(n==0)
            return 0;
        int dp[n];
        int len = 0;
        dp[0] = nums[0];
        for(int i=1;i<n;i++)
            if(nums[i]>dp[len])
                dp[++len] = nums[i];
            else{
                int pos = lower_bound(dp,dp+len,nums[i])-dp;//lower_bound 二分求下界，即 >=nums[i]的第一个位置
                dp[pos] = nums[i];
            }
        return len + 1;
    }
};