【leetcode】300最长上升子序列

reference

动态规划

找到状态很重要，若是把子序列长度定义为状态比较难，所以dp[i] 表示以 nums[i] 结尾的上升子序列的长度。时间复杂度为O(n^2)，空间复杂度O(n)。

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

贪心算法+二分查找

时间复杂度 $O(N \log N)O(NlogN)$，空间复杂度O(N)。

class Solution {
public:
    int lengthOfLIS(vector<int> &nums) {
        int len = nums.size();
        if (len < 2) {
            return len;
        }

        vector<int> tail;
        tail.push_back(nums[0]);
        int end = 0;

        for (int i = 1; i < len; ++i) {
            if (nums[i] > tail[end]) {
                tail.push_back(nums[i]);
                end++;
            } else {
                int left = 0;
                int right = end;
                while (left < right) {
                    int mid = (left + right) >> 1;
                    if (tail[mid] < nums[i]) {
                        left = mid + 1;
                    } else {
                        right = mid;
                    }
                }
                tail[left] = nums[i];
            }
        }
        return end + 1;
    }
};