bzoj3173

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

Sample Output

1
1
2

HINT

100%的数据 n<=100000

 

 

因为后面插入的数一定比前面的大, 所以更后插入的对当前的答案没有任何影响，所以预处理出每个数的最终位置，然后动态规划即可。

时间复杂度O(nlogn)

 #include<stdio.h>
 #include<stdlib.h>
 #include<string>
 #include<string.h>
 #include<iostream>
 #include<algorithm>
 #include<queue>
 #include<math.h>
 #include<vector>
 #include<map>
 #include<set>
 #define il inline
 #define re register
 using namespace std;
 const int N=;
 int l[N],r[N],rnd[N],siz[N],v[N],s[N],cnt,now,root,n,ans[N],g;
 il void update(re int k){
     siz[k]=siz[l[k]]+siz[r[k]]+;
 }
 il void rturn(re int &k){
     int t=l[k];l[k]=r[t];r[t]=k;update(k);update(t);k=t;
 }
 il void lturn(re int &k){
     int t=r[k];r[k]=l[t];l[t]=k;update(k);update(t);k=t;
 }
 il void insert(re int &k,re int rank){
     if(!k){
         k=(++cnt);rnd[k]=rand();siz[k]=;return;
     }
     siz[k]++;
     if(siz[l[k]]<rank){
         insert(r[k],rank-siz[l[k]]-);
         if(rnd[r[k]]<rnd[k]) lturn(k);
     }
     else{
         insert(l[k],rank);
         if(rnd[l[k]]<rnd[k]) rturn(k);
     }
 }
 il int read(){
     re int hs=;re char c=getchar();
     while(!isdigit(c)) c=getchar();
     while(isdigit(c)){
         hs=(hs<<)+(hs<<)+c-'';
         c=getchar();
     }
     return hs;
 }
 il void dfs(re int k){
     if(!k) return;
     dfs(l[k]);
     v[++now]=k;
     dfs(r[k]);
 }
 int main(){
     memset(s,,sizeof(s));s[]=-;n=read();
     for(re int i=,x;i<=n;i++){
         x=read();insert(root,x);
     }
     dfs(root);
     for(re int i=,t;i<=n;i++){
         t=upper_bound(s,s+g+,v[i])-s;
         if(s[t-]<=v[i]){
             s[t]=min(s[t],v[i]);
             ans[v[i]]=t;
             g=max(g,t);
         }
     }
     for(re int i=;i<=n;i++){
         ans[i]=max(ans[i-],ans[i]);
         printf("%d\n",ans[i]);
     }
     return ;
 }