最长上升子序列（dp--O（n*logn））

O(n^2)时递推关系简单， 代码实现也简洁， 唯一的问题是n ^ 2的复杂度在题目给的数据量较大时会超时。

这个问题可以用二分来优化。

做法是构造出一个新的有序的DP数列， 用原数列中的数从左到右维护更新新数列。

初始时DP[0] = s[0]， 从i = 1时遍历原数列， 将每个遍历的数与DP数列的末尾进行比较， 如果大于末尾， 则把DP数列长度提1将s[i]放在DP数列的最后， 如果小于末尾那么替换掉DP数列中比s[i]大的第一个数。

结束后DP数列的长度就是LIS的长度。

从LIS的性质出发，要想得到一个更长的上升序列，该序列前面的数必须尽量的小。

对于序列1,5,8,3,6,7来说，当子序列为1,5,8时，遇到3时，序列已经不能继续变长了。但是，我们可以通过替换，使“整个序列”看上去更小，从而有更大的机会去变长。这样，当替换5-3和替换8-6完成后（此时序列为1,3,6），我们可以在序列末尾添加一个7了。

那为什么复杂度可以是O(NlogN)呢？

关键就在“替换”这一步上，若直接遍历序列替换，每次替换都要O(N)的时间。但是只要我们再次利用LIS的性质——序列是有序的（单调的），就可以用二分查找，在O(logN)的时间内完成一次替换，所以算法的复杂度是O(NlogN)的。

 

代码：

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int n;
    int a[1100];
    int dp[1100];//记录最大子序列
    int pos[1100];//记录最大子串的下标
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    int j=0;
    dp[0]=a[0];
    pos[0]=0;
    for(int i=1;i<n;i++){
        if(a[i]>dp[j]){
            j++;
            dp[j]=a[i];
            pos[j]=i;
        }
        else{
            //flag表示dp中>=a[i]的第一个数的下标
            int flag=lower_bound(dp,dp+j,a[i])-dp;
//            cout<<flag<<endl;
//            cout<<*lower_bound(dp,dp+j,a[i])<<endl;
            dp[flag]=a[i];
            pos[flag]=flag;
        }
    }

    cout<<j+1<<endl;
//    最长子序列的和
//    int res=0;
//    for(int i=0;i<=j;i++){
//        res+=dp[pos[i]];
//    }
//    cout<<res<<endl;
    return 0;
}