Splay模板(序列终结者)

我只是一个存模板的，详细的请看这里http://blog.csdn.net/whai362/article/details/47298133

题目链接：http://www.codevs.cn/problem/4655/

 #include <cstdio>
 #include <cstring>
 #include <cctype>
 #include <cmath>
 #include <set>
 #include <map>
 #include <list>
 #include <queue>
 #include <deque>
 #include <stack>
 #include <string>
 #include <vector>
 #include <iostream>
 #include <algorithm>
 #include <stdlib.h>
 #include <time.h>
 using namespace std;
 typedef long long LL;
 const int INF = 2e9 + 1e8;

 const int MOD = 1e9 + ;
 const double eps = 0.0000000001;

 #define MSET(a, b) memset(a, b, sizeof(a))

 const int maxn = 1e6 + ;
 int max(int a, int b, int c)
 {
     return max(a, max(b, c));
 }

 struct SplayTree
 {
     struct Node
     {
         int son[], big, val, lazy, sz;
         bool rev;
         void init(int _val)
         {
             val = big = _val;
             sz = ;
             lazy = rev = son[] = son[] = ;
         }
     } T[maxn];
     int root, fa[maxn];
     void pushup(int i)
     {
         T[i].big=T[i].val,T[i].sz=;
         if(T[i].son[])
         {
             T[i].big=max(T[i].big,T[T[i].son[]].big);
             T[i].sz+=T[T[i].son[]].sz;
         }
         if(T[i].son[])
         {
             T[i].big=max(T[i].big,T[T[i].son[]].big);
             T[i].sz+=T[T[i].son[]].sz;
         }
     }
     void pushdown(int i)
     {
         if (i == )
             return;
         if (T[i].lazy)
         {
             for (int k = ; k < ; k++)
             {
                 if (T[i].son[k])
                 {
                     T[T[i].son[k]].lazy += T[i].lazy;
                     T[T[i].son[k]].val += T[i].lazy;
                     T[T[i].son[k]].big += T[i].lazy;
                 }
             }
             T[i].lazy = ;
         }
         if (T[i].rev)
         {
             for (int k = ; k < ; k++)
                 if (T[i].son[k])
                     T[T[i].son[k]].rev ^= ;
             swap(T[i].son[], T[i].son[]);
             T[i].rev = ;
         }
     }
     /**  旋转操作
      * 传入x，旋转x与x的父亲这两个节点；
      */
     void rotate(int x, int d)
     {
         int y = fa[x], z = fa[y];
         T[y].son[!d] = T[x].son[d], fa[T[x].son[d]] = y;
         T[x].son[d] = y, fa[y] = x;
         T[z].son[T[z].son[] == y] = x, fa[x] = z;
         pushup(y);
     }
     void splay(int x, int goal)
     {
         if (x == goal)
             return;
         while (fa[x] != goal)
         {
             int y = fa[x], z = fa[y];
             pushdown(z), pushdown(y), pushdown(x);
             int dirx = (T[y].son[] == x), diry = (T[z].son[] == y);
             if (z == goal)
                 rotate(x, dirx);
             else
             {
                 if (dirx == diry)
                     rotate(y, diry);
                 else
                     rotate(x, dirx);
                 rotate(x, diry);
             }
         }
         pushup(x);
         if (goal == )
             root = x;
     }
     /**
      * select(pos) 返回第pos+1个元素；
      */
     int Select(int pos)
     {
         int u = root;
         pushdown(u);
         while (T[T[u].son[]].sz != pos)
         {
             if (pos < T[T[u].son[]].sz)
                 u = T[u].son[];
             else
             {
                 pos = pos - ( + T[T[u].son[]].sz);
                 u = T[u].son[];
             }
             pushdown(u);
         }
         return u;
     }
     void update(int l, int r, int val)
     {
         int x = Select(l - ), y = Select(r + );
         splay(x, );
         splay(y, x);
         T[T[y].son[]].val += val;
         T[T[y].son[]].big += val;
         T[T[y].son[]].lazy += val;
     }
     void turn(int l, int r)
     {
         int x = Select(l - ), y = Select(r + );
         splay(x, );
         splay(y, x);
         T[T[y].son[]].rev ^= ;
     }
     int query(int l, int r)
     {
         int x = Select(l - ), y = Select(r + );
         splay(x, );
         splay(y, x);
         return T[T[y].son[]].big;
     }
     int build(int L, int R)
     {
         if (L > R)
             return ;
         if (L == R)
             return L;
         int mid = (L + R) >> , sL, sR;
         T[mid].son[] = sL = build(L, mid - );
         T[mid].son[] = sR = build(mid + , R);
         fa[sL] = fa[sR] = mid;
         pushup(mid);
         return mid;
     }

     void init(int n)
     {
         T[].init(-INF), T[n + ].init(-INF);
         for (int i = ; i <= n + ; i++)
             T[i].init();
         root = build(, n + ), fa[root] = ;
         fa[] = , T[].son[] = root, T[].sz = ;
     }
 } re;

 int main()
 {
     int n, m;
     scanf("%d%d", &n, &m);
     re.init(n);
     for (int i = , a, b, c, d; i < m; i++)
     {
         scanf("%d", &a);
         if (a == )
         {
             scanf("%d%d%d", &b, &c, &d);
             re.update(b, c, d);
         }
         else if (a == )
         {
             scanf("%d%d", &b, &c);
             re.turn(b, c);
         }
         else
         {
             scanf("%d%d", &b, &c);
             printf("%d\n", re.query(b, c));
         }
     }
     return ;
 }

 /**************************************************/
 /**             Copyright Notice                 **/
 /**  writer: wurong                              **/
 /**  school: nyist                               **/
 /**  blog  : http://blog.csdn.net/wr_technology  **/
 /**************************************************/