领扣300.最长上升子序列（LIS）

题目
领扣300
给定一个无序的整数数组，找到其中最长上升子序列的长度。
示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

参考链接
方法一：动态规划，时间复杂度O(n^2)
将问题分阶段，查找最长上升子序列->查找上升子序列的终点。设F[i]为以A[i]结尾的最长上升子序列的长度。求出状态转移方程：
F [ i ] = max { F [ j ] + 1 ，F [ i ] } (1 <= j < i，A[ j ] < A[ i ])

#include <iostream>
#include<iomanip>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N=10001;

int main() {

    int n,ans=0;
    int a[N],dp[N];
    memset(a,0,sizeof(a));
    memset(dp,0,sizeof(dp));

    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];

    for(int i=0;i<n;i++){
        dp[i]=1;
        for(int j=0;j<i;j++){
            if(a[j]<a[i])
                dp[i]=max(dp[i],dp[j]+1);
        }
        ans= max(ans,dp[i]);
    }
    cout<<ans<<endl;
    
    return 0;

}

方法二：树状维护，时间复杂度O(nlogn)
当O(n^2)时，dp状态转移方程为：
F [ i ] = max { F [ j ] + 1 ，F [ i ] } (1 <= j < i，A[ j ] < A[ i ])
当我们在查找F[j]的最大值时，需要遍历一次数组，时间复杂度较大，可以使用数据结构化来优化这个过程。
把A数组从小到大排序，同时把A[i]在排序前的序号记录下来。从小到大枚举A[i]，每次用编号小于等于A[i]编号长度的LIS长度+1来更新结果。
（树状数组球LIS不去重->最长不下降子序列）

#include <iostream>
#include<iomanip>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N=10001;

struct Node{
    int val;
    int num;
}a[N];
int bp[N];

bool cmp(Node x1,Node x2){
    return x1.val==x2.val?x1.num<x2.num:x1.val<x2.val;
}

void modify(int x,int y,int n)//把val[x]替换为val[x]和y中较大的数
{
    for(;x<=n;x+=x&(-x)) bp[x]=max(bp[x],y);
}

int main() {

    int ans=0,res=0;
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>a[i].val;
        a[i].num=i;//记录a[i]的原编号
    }
    sort(a,a+n,cmp);
    for(int i=0;i<n;i++){//按权重枚举
        int t=a[i].num;
        int max_j;
        for(;t;t-=t&(-t))
            ans=max(ans,bp[t]);
        max_j = ans;
        //长度 +1 ，更新LIS长度
        modify(a[i].num,++max_j,n);
        //更新答案
        res=max(res,max_j);
    }
    
    cout<<res<<endl;
    return 0;
}

方法三：贪心算法+二分查找，时间复杂度O(nlogn)

新建一个low数组，low[I]表示长度为i的LIS结尾元素的最小值。对于上升序列而言，结尾元素越小，越有有利于接其他元素，变长的可能性越大。对于每一个a[i],如果a[i]>low[当前最长的LIS长度],就把a[i]接到当前最长的LIS后面，即low[当前最长的LIS长度++]=a[i]。

#include <iostream>
#include<iomanip>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N=10001;
int low[N],a[N];
int n,ans=0;

int binary_search(int *a,int r,int x)
{//返回a数组中第一个大于等于x的位置
    int l=1,mid;
    while(l<=r){
        mid=(l+r)/2;
        if(a[mid]<=x) l=mid+1;
        else r=mid-1;
    }
    return l;
}

int main() {

    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        low[i]=N;
    }
    low[1]=a[1];
    ans=1;
    for(int i=2;i<=n;i++){
        if(a[i]>low[ans])
            low[++ans]=a[i];
        else
            low[binary_search(low,ans,a[i])] =a[i];
    }

    cout<<ans<<endl;
    return 0;
}