给出一个无序的整形数组，找到最长上升子序列的长度。

例如，

给出 [10, 9, 2, 5, 3, 7, 101, 18]，

最长的上升子序列是 [2, 3, 7, 101]，因此它的长度是4。因为可能会有超过一种的最长上升子序列的组合，因此你只需要输出对应的长度即可。

你的算法的时间复杂度应该在 O(n2) 之内。

进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?

详见：https://leetcode.com/problems/longest-increasing-subsequence/description/

Java实现：



class Solution {
    public int lengthOfLIS(int[] nums) {
        int n=nums.length;
        if(n==0||nums==null){
            return 0;
        }
        int[] dp=new int[n];
        Arrays.fill(dp,1);
        int res=1;
        for(int i=1;i<n;++i){
            for(int j=0;j<i;++j){
                if(nums[j]<nums[i]&&dp[j]+1>dp[i]){
                    dp[i]=dp[j]+1;
                }
                if(res<dp[i]){
                    res=dp[i];
                }
            }
        }
        return res;
    }
}


C++实现：

方法一：



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


方法二：



class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int size=nums.size();
        if(size==0||nums.empty())
        {
            return 0;
        }
        vector<int> res;
        for(int i=0;i<size;++i)
        {
            auto it=std::lower_bound(res.begin(),res.end(),nums[i]);
            if(it==res.end())
            {
                res.push_back(nums[i]);
            }
            else
            {
                *it=nums[i];
            }
        }
        return res.size();
    }
};