最长递增子序列

51NOD1134 最长递增子序列

n^2的算法：

n^2的算法就是两层循环，想法很简单：dp[i]记录的是长度到i的最大长度。

每次对dp[i]更新的时候，找到前面的数的最大dp[j](j < i)然后如果a[i] > a[j],就进行更新；

template<class T>
int LIS(T a[],int n)
{
int i,j;
int ans=1;
int m=0;
int *dp=new int[n+1];
dp[1]=1;
for(i=2;i<=n;i++)
{
m=0;
for(j=1;j<i;j++)
{
if(dp[j]>m&&a[j]<a[i])
m=dp[j];
}
dp[i]=m+1;
if(dp[i]>ans)
ans=dp[i];
}
return ans;
}

nlogn的算法：

维护一个一维数组dp，并且这个数组是动态扩展的，初始大小为1，dp[i]表示最长上升子序列长度是i的所有子串中末尾最小的那个数，根据这个数字，我们可以比较知道，只要当前考察的这个数比dp[i]大，那么当前这个数一定能通过c[i]构成一个长度为i+1的上升子序列。当然我们希望在dp数组中找一个尽量靠后的数字，这样我们得到的上升子串的长度最长，查找的时候使用二分搜索，这样时间复杂度便下降了

所以要进行二分找刚好大于a[i]的那个数在进行替换；



我的：

#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<cmath>
#include<string>
#include<cstring>
#include<map>
#include<vector>
#include<set>
#include<algorithm>

using namespace std;

const int maxn=100000+5;

int arr[maxn],ans[maxn];
int len;

int binary__search(int i)
{
int left=0,right=len,mid;
while(left<right)
{
mid=(left+right)/2;
if(ans[mid]>=arr[i])
{
right=mid;
}
else left=mid+1;
}
return left;
}

int main()
{
int n;
while(~scanf("%d",&n))
{
for(int i=0;i<n;i++)
{
scanf("%d",&arr[i]);
}
ans[0]=arr[0];
len=0;
for(int i=1;i<n;i++)
{
if(arr[i]>ans[len])
ans[++len]=arr[i];
else
{
//                int t=lower_bound(ans,ans+len,arr[i])-ans;//lower_bound（a,a+n,b）-a;二分函数返回的是一个有序的数列a中刚好大于给出的b的元素的地址

int t=binary__search(i);//或者自己编写二分函数
ans[t]=arr[i];
}
}
printf("%d\n",len+1);
}
return 0;
}