最长上升子序列LIS（Longest Increasing Subsequence）

给出一个数组，求里边上升子串的长度。

如{1,3,2,7}

可以发现上升子串有{1,2,7}或者{3,7}或者{2,7}最长的是{1,2,7}长度为3

下边给出n^2算法

#include<bits/stdc++.h>
using namespace std;
int n,ans;
int dp[1005],a[1005];//dp[i]表示以i为结尾的最长上升子序列的长度
int main()
{
    memset(dp,0,sizeof(dp));
    cin>>n;
    for(int i=0; i<n; i++)
        cin>>a[i];
    dp[0]=1;//以0为结尾的长度为1
    ans=dp[0];
    for(int i=1; i<n; i++)//以a[i]为结尾的长度
    {
        dp[i]=1;//初始为1
        for(int j=0;j<i;j++)//判断先前的元素
            if(a[i]>a[j] && dp[j]+1>dp[i])//如果这个数比先前的数大，而且dp[i]<dp[j]+1就更新值
                dp[i]=dp[j]+1;
        ans=max(ans,dp[i]);//更新最终答案
    }
    cout<<ans<<endl;
    return 0;
}

其实还有一种nlogn的算法，感觉用处不大而且很复杂很绕，备用吧

/*
对于一个上升子序列，如果存在两个元素对前一个子串来说dp[x]=dp[y]
且x<y且a[x]<a[y]，那么我必然会选择纳入a[x]这个元素，这样会让上升的空间更大
因此对于长度为i-1的子串来说，长度为i的选择方法会有多种
那么，只保留一个值最小的元素用c来存
那么，c必然是不下降的，这样就可以用二分去优化
*/
#include <bits/stdc++.h>
using namespace std;
int find(int *a,int len,int n)//修改后的二分查找，若返回值为x，则a[x]>=n
{
    int left=0,right=len,mid=(left+right)/2;
    while(left<=right)
    {
        if(n>a[mid]) left=mid+1;
        else if(n<a[mid]) right=mid-1;
        else return mid;
        mid=(left+right)/2;
    }
    return left;
}

int main(void)
{
    int n,a[100],c[100],i,j,len;
    //新开一变量len,用来储存每次循环结束后c中已经求出值的元素的最大下标
    while(cin>>n)
    {
        for(i=0; i<n; i++)
            cin>>a[i];
        c[1]=a[0];
        len=1;//此时只有c[1]求出来，最长递增子序列的长度为1.
        for(i=1; i<n; i++)
        {
            j=find(c,len,a[i]);//二分查找的是大于等于a[i]的c[j]
            c[j]=a[i];
            if(j>len)//要更新len,另外补充一点：由二分查找可知j只可能比len大1
                len=j;//更新len
        }
        cout<<len<<endl;
    }
    return 0;
}