300.最长递增子序列

300.最长递增子序列_第1张图片
300.最长递增子序列_第2张图片
贪心+二分查找

  • 贪心:上升子序列尽可能长,序列上升尽可能慢,每次在上升子序列后加上的那个数尽可能小
  • 数组d,长度为len的最长上升子序列,d[i]为长度为i的最长上升子序列的末尾元素最小值,起始len=1,d[1]=nums[0]
  • 数组d是递增的
  • 遍历nums,更新d和len
  • 若nums[j]>d[len],则len=len+1,d[len+1]=nums[j]
  • 否则,在d[1…len]中找满足d[i-1]
  • 因为d是递增的,可以二分查找找到d中从右到左第一个比nums[j]小的下标pos,并更新d[pos+1]=nums[j]
  • 示例 [0,8,4,12,2,5,6]
  • len=1 d=[0]
  • len=2 d=[0,8]
  • len=2 d=[0,4]
  • len=3 d=[0,4,12]
  • len=3 d=[0,2,12]
  • len=3 d=[0,2,5]
  • len=4 d=[0,2,5,6]
  • 最终的d=[0,2,5,6],len为4
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        if(n==0) return 0;
        int len=1;
        vector<int> d(n+1,0);
        d[1]=nums[0];
        
        for(int j=1;j<n;j++){
            if(nums[j]>d[len]){
                d[len+1]=nums[j];
                len=len+1;
            }else{
                int l=1,r=len,pos=0;
                while(l<=r){
                    int mid=(l+r)/2;
                    if(d[mid]<nums[j]){
                        pos=mid;
                        l=mid+1;
                    }else{
                        r=mid-1;
                    }
                }
                d[pos+1]=nums[j];
            }
        }
        return len;
    }
};

你可能感兴趣的:(算法,数据结构)