300. Longest Increasing Subsequence_your algorithm should try to run in no more than o-优快云博客

本文介绍了一种寻找最长递增子序列长度的算法，并提供了两种实现方式：一种时间复杂度为O(n^2)，另一种优化后的时间复杂度为O(n log n)。通过实例展示了算法的具体应用。

iven an unsorted array of integers, find the length of longest increasing subsequence.

For example,
Given [10, 9, 2, 5, 3, 7, 101, 18],
The longest increasing subsequence is [2, 3, 7, 101], therefore the length is 4. Note that there may be more than one LIS combination, it is only necessary for you to return the length.

Your algorithm should run in O(n2) complexity.

Follow up: Could you improve it to O(n log n) time complexity?

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

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp;
        for (int i = 0; i < nums.size(); ++i){

            int lo = 0, hi = dp.size();
            while (lo < hi){
                int mi = (lo + hi)/2;
                if (dp[mi] < nums[i]) lo = mi + 1;
                else hi = mi;
            }
            if (hi == dp.size())
                dp.push_back(nums[i]);
            else dp[hi] = nums[i];
        }
        return dp.size();
    }
};

两种算法：1：O(n*n) 2：O(nlogn)