Longest Increasing Subsequence(LIS)

1.排序+LCS

2.DP，时间复杂度为O(n^2)

int LIS(int *A,int n)
{	
    //f[i]表示以A[i]为尾元素的最长递增子序列的长度
    int *f=new int[n];
    int max=1; 
    for(int i=0;i<n;++i) 
    { 
        f[i]=1; 
        for(int j=0;j<i;++j) 
        { 
            if(A[j]<A[i]&&f[j]+1>f[i])f[i]=f[j]+1; 
        } 
        if(f[i]>max)max=f[i]; 
    } 
    delete [] f; 
    return max;
}

3.时间复杂度为O(nlogn)

2 1 5 3 6 4 8 9 7

d[0]=2,MaxV[1]=2,len=1;

d[1]=1,MaxV[1]=1,len=1;

d[2]=5,MaxV[1..2]={1,5},len=2;

d[3]=3,MaxV[1..2]={1,3},len=2;

d[4]=6,MavV[1..3]={1,3,6},len=3;

d[5]=4,MaxV[1..3]={1,3,4},len=3;

d[6]=8,MaxV[1..4]={1,3,4,8},len=4;

d[7]=9,MaxV[1..5]={1,3,4,8,9},len=5;

d[8]=7,MaxV[1..5]={1,3,4,7,9},len=5;

//求最小的i使得a[i]大于x
int binarySearch(int *a,int n,int x)
{  
    int left=1,right=n;  
    while(left<right-1)  
    {  
        int mid=left+(right-left)/2; 
        if(a[mid]<=x)left=mid+1;  
        else right=mid;
    }  
    if(a[left]>x)return left;
    if(a[right]>x)return right;
    return -1;
}  

int LIS(int *A,int n)  
{
    //MaxV[i]表示长度为i的递增子序列的尾元素的最小值
    int *MaxV=new int[n+1];
    MaxV[1]=A[0];
    int len=1;
    for(int i=1;i<n;++i)
    {
        if(A[i]>MaxV[len])MaxV[++len]=A[i];
        else
        {
            int pos=binarySearch(MaxV,len,A[i]);
            MaxV[pos]=A[i];
        }
    }
    delete [] MaxV;
    return len;
} 

4.双端LIS

int doubleEndLIS(int *A,int n)  
{    
    //f[i]表示从0到i以i结束的最长递增子序列
    int *f=new int[n]; 
    for(int i=0;i<n;++i) 
    { 
        f[i]=1; 
        for(int j=0;j<i;++j) 
        { 
            if(A[j]<A[i]&&f[j]+1>f[i])f[i]=f[j]+1; 
        } 
    }
    //g[i]表示从n-1到i以i结束的最长递增子序列
    int *g=new int[n]; 
    for(int i=n-1;i>=0;--i) 
    { 
        g[i]=1; 
        for(int j=n-1;j>i;--j) 
        { 
            if(A[j]<A[i]&&g[j]+1>g[i])g[i]=g[j]+1; 
        } 
    } 
    int max=1; 
    for(int i=0;i<n;++i) 
    { 
        if(f[i]+g[i]-1>max)max=f[i]+g[i]-1; 
    } 
    delete [] f,g; 
    return max;
}