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 + 7;
const double eps = 0.0000000001;
 
#define MSET(a, b) memset(a, b, sizeof(a))

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

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

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

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

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