F - 最长递增子序列

给出长度为N的数组，找出这个数组的最长递增子序列。(递增子序列是指，子序列的元素是递增的）
例如：5 1 6 8 2 4 5 10，最长递增子序列是1 2 4 5 10。

Input
第1行：1个数N，N为序列的长度(2 <= N <= 50000)
第2 - N + 1行：每行1个数，对应序列的元素(-10^9 <= Si
<= 10^9)
Output
输出最长递增子序列的长度。
Sample Input

8
5
1
6
8
2
4
5
10

Sample Output

5

方法一：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
int a[50010],dp[50010];
int main()
{
    int n,ans=0;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(int i=1;i<=n;i++){
        dp[i]=1;
        int j=i-1;
        while(j>0){
            if(a[i]>a[j]){
                dp[i]=max(dp[i],dp[j]+1);
            }
            j--;
        }
    ans=max(ans,dp[i]);
    }
    printf("%d\n",ans);
}

遗憾，这方法超时啦。

方法二：（nlogn法）

/*
性质：
1. d[k]在计算过程中单调不升；           

2. d数组是有序的，d[1]<d[2]<..d[n]。

    利用这两个性质，可以很方便的求解：

1. 设当前已求出的最长上升子序列的长度为len（初始时为1），每次读入一个新元素x：

2. 若x>d[len]，则直接加入到d的末尾，且len++；（利用性质2）

   否则，在d中二分查找，找到第一个比x小的数d[k]，并d[k+1]=x，在这里x<=d[k+1]一定成立（性质1,2）。*/
/*解法： 
1. 设当前最长递增子序列为len,考虑元素a[i]; 
2. 若d[len]<a[i],则len++，并将d[len]=a[i]; 
   否则,在d[0-len]中二分查找,找到第一个比它小的元素d[k],并d[k+1]=a[i].() 
*/  
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
int a[50010],f[50010];
int solve(int temp,int* f,int left,int right){
    while(left<=right){
        int mid=(left+right)/2;
        if(temp>f[mid]&&temp<=f[mid+1])
            return mid;
        else if(temp>f[mid])
            left=mid+1;
        else
            right=mid-1;
    }
    return 0;
}//二分查找出小于a[i]的最大那个。
int LIS(int* a,int n,int* f){
    int i,j;
    f[1]=a[1];
    int len=1;
    for(i=2;i<=n;i++){
        if(a[i]>f[len])
            j=++len;
        else
            j=solve(a[i],f,1,len)+1;
        f[j]=a[i];
    }
    return len;
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i=1;i<=t;i++)
        scanf("%d",&a[i]);
    printf("%d",LIS(a,t,f));
    return 0;
}