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=1000001;
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]]+1;
}
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]=1;return;
    }
    siz[k]++;
    if(siz[l[k]]<rank){
        insert(r[k],rank-siz[l[k]]-1);
        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=0;re char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)){
        hs=(hs<<3)+(hs<<1)+c-'0';
        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,127,sizeof(s));s[0]=-1000000000;n=read();
    for(re int i=1,x;i<=n;i++){
        x=read();insert(root,x);
    }
    dfs(root);
    for(re int i=1,t;i<=n;i++){
        t=upper_bound(s,s+g+1,v[i])-s;
        if(s[t-1]<=v[i]){
            s[t]=min(s[t],v[i]);
            ans[v[i]]=t;
            g=max(g,t);
        }
    }
    for(re int i=1;i<=n;i++){
        ans[i]=max(ans[i-1],ans[i]);
        printf("%d\n",ans[i]);
    }
    return 0;
}