[Tjoi2013]最长上升子序列

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

题解：

splay，按位置维护，先加入的点小，后加的大

每次加入直接模拟splay的插入。

由于没有延迟标记，所以不需要pushdown，但要pushup

每次pushup要维护两个值，当前节点结尾的最长上升子序列，当前子树的最长子序列

推测可知，当前节点结尾的最长上升子序列只由左节点子树的序列的递推而来，因为左子树位置在前面，且小

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 const int MAXN=;
 int tot2,tot1,s[MAXN],pre[MAXN],ch[MAXN][],key[MAXN];
 int size[MAXN],root,n,m,maxn[MAXN],g[MAXN];
 void NewNode(int &x,int fa,int k)
 {
     if (tot2) x=s[tot2--];
     else x=++tot1;
     key[x]=k;
     size[x]=;
     pre[x]=fa;
     ch[x][]=ch[x][]=;
 }
 void pushup(int x)
 {
     int lson=ch[x][],rson=ch[x][];
     size[x]=size[lson]+size[rson]+;
     maxn[x]=max(max(g[x],maxn[rson]),maxn[lson]);
     if (key[x]==2e9||key[x]==) maxn[x]=,g[x]=;
 }
 void rotate(int x,bool t)
 {
     int y=pre[x];
     ch[y][!t]=ch[x][t];
     pre[ch[x][t]]=y;
     if (pre[y])
         ch[pre[y]][ch[pre[y]][]==y]=x;
     pre[x]=pre[y];
     ch[x][t]=y;
     pre[y]=x;
     pushup(y);pushup(x);
 }
 int getkth(int r,int k)
 {
     int x=size[ch[r][]]+;
     if (k==x) return r;
     if (k<x) getkth(ch[r][],k);
     else getkth(ch[r][],k-x);
 }
 void splay(int x,int goal)
 {
     while (pre[x]!=goal)
     {
         if (pre[pre[x]]==goal)
         {
             rotate(x,ch[pre[x]][]==x);
         }
         else
         {
             int y=pre[x],kind=ch[pre[y]][]==y;
             if (ch[y][kind]==x)
             {
                 rotate(x,!kind);
                 rotate(x,kind);
             }
             else
             {
                 rotate(y,kind);
                 rotate(x,kind);
             }
         }
     }
     pushup(x);
     if (goal==) root=x;
 }
 int main()
 {int i,x;
     cin>>n;
     NewNode(root,,2e9);
     NewNode(ch[root][],root,);
     for (i=; i<=n; i++)
     {
         scanf("%d",&x);
         splay(getkth(root,x+),);
         splay(getkth(root,x+),root);
         NewNode(ch[ch[root][]][],ch[root][],i);
         splay(ch[ch[root][]][],);
         g[root]=maxn[ch[root][]]+;
         pushup(root);
         printf("%d\n",maxn[root]);
     }
 }