bzoj3173 Splay 维护前缀中的最大值

大致题意：

有一个空序列，依次插入1~N到该序列中，每次指定插入的位置，每次插入完成返回当前序列的LIS的长度。

题解：

设dp[i]表示 前缀1~i的最长上升子序列的长度。

因为是按照递增顺序插入的，所以当刚插入完某个数到i位置（此时能保证该数是当前序列的最大值）dp[i] = max{ dp[j] | j<i }，答案 ans=max{ dp[i] | i in [1,len] }

因为要支持动态插入，所以要用BST来做，每个节点代表一个位置（即树的中序遍历就是该序列），每个节点维护dp[i]和 dpmax[i] = max{ dp[i] | i in the subtree }

代码：

 #include <cstdio>
 #include <iostream>
 #define maxn 100010
 using namespace std;

 struct Splay {
     int pre[maxn], son[maxn][], siz[maxn], ntot, root;
     int dp[maxn], dmax[maxn];

     Splay() {
         root = ntot = ;
     }
     void update( int nd ) {
         siz[nd] = siz[son[nd][]] + siz[son[nd][]] + ;
         dmax[nd] = max( dp[nd], max( dmax[son[nd][]], dmax[son[nd][]] ) );
     }
     void rotate( int nd, int d ) {
         int p = pre[nd];
         int s = son[nd][!d];
         int ss = son[s][d];

         son[nd][!d] = ss;
         son[s][d] = nd;
         if( !p ) root = s;
         else son[p][ nd==son[p][] ] = s;

         pre[s] = p;
         pre[nd] = s;
         if( ss ) pre[ss] = nd;

         update(nd);
         update(s);
     }
     void splay( int nd, int top ) {
         while( pre[nd]!=top ) {
             int p = pre[nd];
             if( pre[p]==top ) {
                 rotate( p, son[p][]==nd );
             } else {
                 int pp = pre[p];
                 int pl = p == son[pp][];
                 int nl = nd == son[p][];
                 if( pl==nl ) {
                     rotate( pp, pl );
                     rotate( p, nl );
                 } else {
                     rotate( p, nl );
                     rotate( pp, pl );
                 }
             }
         }
     }
     int find( int pos ) {    //    pos in [1,sz]
         int nd = root;
         while() {
             int ls = siz[son[nd][]];
             if( pos<=ls ) {
                 nd = son[nd][];
             } else if( pos>=ls+ ) {
                 nd = son[nd][];
                 pos -= ls+;
             } else {
                 return nd;
             }
         }
     }
     int premax( int pos ) {
         int nd = root;
         int rt = ;
         while() {
             int ls = siz[son[nd][]];
             if( pos<=ls ) {
                 nd = son[nd][];
             } else if( pos>=ls+ ) {
                 rt = max( rt, max( dp[nd], dmax[son[nd][]] ) );
                 nd = son[nd][];
                 pos -= ls+;
             } else {
                 rt = max( rt, max( dp[nd], dmax[son[nd][]] ) );
                 break;
             }
         }
         return rt;
     }
     int newnode( int p, int v ) {
         int nd = ++ntot;
         pre[nd] = p;
         son[nd][] = son[nd][] = ;
         siz[nd] = ;
         dp[nd] = dmax[nd] = v;
         return nd;
     }
     void insert( int pos ) {
         if( !root ) {
             root = newnode( ,  );
             return;
         }
         if( pos== ) {
             int nd = root;
             while( son[nd][] ) nd=son[nd][];
             son[nd][] = newnode( nd,  );
             update( nd );
             splay( nd,  );
             return;
         }
         int nd = find( pos );
         int nw = newnode( nd,premax(pos)+ );
         int s = son[nd][];
         son[nd][] = nw;
         son[nw][] = s;
         pre[nw] = nd;
         if( s ) pre[s] = nw;
         update( son[nd][] );
         update( nd );
         splay( nd,  );
     }
     void print( int nd ) {
         if( !nd ) return;
         print( son[nd][] );
         printf( "%d(%d,%d,%d,%d,%d) ", dp[nd], nd, pre[nd], son[nd][], son[nd][], nd==son[pre[nd]][] );
         print( son[nd][] );
     }
 };

 Splay T;
 int n;
 int main() {
     //freopen( "input", "r", stdin );
     scanf( "%d", &n );
     for( int i=,pos; i<=n; i++ ) {
         scanf( "%d", &pos );
         T.insert( pos );
 //        T.print(T.root);
 //        printf( "\n" );
         printf( "%d\n", T.dmax[T.root] );
     }
 }