Description
给定一个序列,初始为空。现在我们将1到N的数字插入到序列中,每次将一个数字插入到一个特定的位置。每插入一个数字,我们都想知道此时最长上升子序列长度是多少?
Input
第一行一个整数N,表示我们要将1到N插入序列中,接下是N个数字,第k个数字Xk,表示我们将k插入到位置Xk(0<=Xk<=k-1,1<=k<=N)
Output
N行,第i行表示i插入Xi位置后序列的最长上升子序列的长度是多少。
Sample Input
3
0 0 2
0 0 2
Sample Output
1
1
2
1
2
HINT
100%的数据 n<=100000
Source
经过思考发现,由于是从小到大插入的,所以后插入的数对于先前插入的数没有影响,所以可以直接把最后的序列先求出来,再算一遍LIS就完了
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxn=100007;
int root;
int val[maxn];
int size1=0;
int rnd[maxn];
int size[maxn];
int ans[maxn];
int cnt=0;
int aa=0;
int tr[maxn][2];
void update(int k)
{
size[k]=size[tr[k][0]]+size[tr[k][1]]+1;
}
void lturn(int &k){
int t=tr[k][1];
tr[k][1]=tr[t][0];
tr[t][0]=k;
update(k);
update(t);
k=t;
}
void rturn(int &k){
int t=tr[k][0];
tr[k][0]=tr[t][1];
tr[t][1]=k;
update(k);
update(t);
k=t;
}
void insert(int &k,int rank){
if(k==0){
k=++size1;
size[k]=1;
rnd[k]=rand();
val[k]=++aa;
return;
}
size[k]++;
if(size[tr[k][0]]<rank)
{
insert(tr[k][1],rank-size[tr[k][0]]-1);
if(rnd[tr[k][1]]<rnd[k]){
lturn(k);
}
}
else{
insert(tr[k][0],rank);
if(rnd[tr[k][0]]<rnd[k]){
rturn(k);
}
}
}
void dfs(int x){
if(!x) return;
dfs(tr[x][0]);
ans[++cnt]=val[x];
dfs(tr[x][1]);
}
int g[maxn];
int d[maxn];
int main(){
memset(g,127/3,sizeof(g));
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
int u;
scanf("%d",&u);
insert(root,u);
}
dfs(root);
int ans1=0;
for(int i=1;i<=n;i++)
{
int u=lower_bound(g+1,g+n+1,ans[i])-g;
d[ans[i]]=u;
g[u]=ans[i];
ans1=max(ans1,u);
}
for(int i=1;i<=n;i++)
{
d[i]=max(d[i],d[i-1]);
printf("%d\n",d[i]);
}
return 0;
}