[AHOI 2006][BZOJ 1269]文本编辑器editor

好吧，我承认这是我用来刷随笔数的喵~

这是一道 splay 裸题，但还是有想本傻 X 一样根本不会写 splay 的，于是乎又用 treap 水过了

splay 的常数我还是知道的，所以真是不知道那些 500ms 的人都是怎么跑出来的，跪求大爷指导

近期要学一下可持久化的 AVL 和尝试把 treap 的代码非递归化模板化(话说我真的不知道原始的 treap 怎么写了)

写完后也会发出来的喵~

 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 const int size=;
 const int inf=0x7FFFFFFF;
 
 template <class type>
 inline void swap(type & a, type & b)
     {type t=a; a=b; b=t;}
 
 namespace treap
 {
     struct node
     {
         char ch; int size;
         int weight;
         bool rev;
         node * left, * right;
         inline node():size() {left=right=this;}
         inline void pushdown() {if (rev) swap(left, right), left->rev^=, right->rev^=, rev=;}
         inline void maintain() {size=left->size+right->size+;}
     };
     node * null=new node();
     node MEM[size], * PORT=MEM;
 
     inline node * newnode(char ch, int size)
     {
         node * ret=PORT++;
         ret->ch=ch; ret->size=size;
         ret->rev=;
         ret->left=ret->right=null;
         return ret;
     }
     node * newtreap(char * s, int l, int w)
     {
         if (!l) return null;
         node * ret=newnode(s[l>>], l);
         ret->weight=rand()%w+;
         if (l==) return ret;
         ret->left=newtreap(s, l>>, ret->weight);
         ret->right=newtreap(s+(l>>)+, l-(l>>)-, ret->weight);
         return ret;
     }
     void split(node * t, int k, node *& l, node *& r)
     {
         if (t==null) l=r=null;
         else
         {
             t->pushdown();
             if (t->left->size<k)
             {
                 l=t;
                 split(t->right, k-t->left->size-, t->right, r);
                 l->maintain();
             }
             else
             {
                 r=t;
                 split(t->left, k, l, t->left);
                 r->maintain();
             }
         }
     }
     node * merge(node * l, node * r)
     {
         if (l==null) return r;
         if (r==null) return l;
         if (l->weight>r->weight)
         {
             l->pushdown();
             l->right=merge(l->right, r);
             l->maintain();
             return l;
         }
         else
         {
             r->pushdown();
             r->left=merge(l, r->left);
             r->maintain();
             return r;
         }
     }
 }
 
 int N, mouse;
 char str[size];
 treap::node * root=treap::newnode(' ', );
 void print(treap::node * );
 inline void insert(char * , int);
 inline void remove(int);
 inline void rotate(int);
 inline char get();
 
 int main()
 {
     int x;
 
     scanf("%d", &N); mouse=;
     root->weight=rand();
     for ( ;N;N--)
     {
         scanf("%s", str);
         if (str[]=='G') putchar(get()), putchar('\n');
         else if (str[]=='M') scanf("%d", &x), mouse=x;
         else if (str[]=='P' && mouse) mouse--;
         else if (str[]=='N' && mouse<root->size) mouse++;
         else if (str[]=='R') scanf("%d", &x), rotate(x);
         else if (str[]=='D') scanf("%d", &x), remove(x);
         else
         {
             scanf("%d", &x);
             do gets(str); while (!strlen(str));
             insert(str, x);
         }
     }
 
     return ;
 }
 inline void insert(char * s, int l)
 {
     treap::node * L, * M, * R;
     treap::split(root, mouse, L, R);
     M=treap::newtreap(s, l, inf);
     L=treap::merge(L, M);
     root=treap::merge(L, R);
 }
 inline void remove(int l)
 {
     treap::node * L, * M, * R;
     treap::split(root, mouse, L, R);
     treap::split(R, l, M, R);
     root=treap::merge(L, R);
 }
 inline void rotate(int l)
 {
     treap::node * L, * M, * R;
     treap::split(root, mouse, L, R);
     treap::split(R, l, M, R);
     M->rev^=;
     L=treap::merge(L, M);
     root=treap::merge(L, R);
 }
 inline char get()
 {
     treap::node * i=root;
     int k=mouse+;
     for ( ; ; )
     {
         i->pushdown();
         if (i->left->size+==k) return i->ch;
         if (i->left->size+<k)
         {
             k-=i->left->size+;
             i=i->right;
         }
         else
             i=i->left;
     }
 }

本傻装B不成反被艹系列