【BZOJ 1251】序列终结者【裸splay】

Description

给定一个长度为N的序列，每个序列的元素是一个整数（废话）。要支持以下三种操作：
1. 将[L,R]这个区间内的所有数加上V。
2. 将[L,R]这个区间翻转，比如1 2 3 4变成4 3 2 1。
3. 求[L,R]这个区间中的最大值。 最开始所有元素都是0。

题解

splay还有什么好说的呢。

（本文纯粹为了保存一个最适合自己的代码）

代码

/*
本文用数组来表示结点
如果要提取区间[a,b]，将a-1转到根节点，b+1转到根节点的右边，这样根节点的左子树就是我们要操作的结点 
基本的我认为操作类似线段树，不再赘述。 
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

#define ls(n) node[n].ch[0]
#define rs(n) node[n].ch[1]
const int N = 100010;
const int INF = 0x3f3f3f3f;

struct Splay{
    struct Node{
        int fa,ch[2];
        bool flip;
        int v,add,maxn,s;
        void init(int val)
        {
            v = maxn = val;
            s = 1;
            add = flip = ch[0] = ch[1] = 0;
        }
    }node[N];
    int root;
    //维护一个结点 
    void pushup(int n)
    {
        node[n].maxn = max(node[n].v,max(node[ls(n)].maxn,node[rs(n)].maxn));
        node[n].s = node[ls(n)].s+node[rs(n)].s+1;
    }
    //标记向下传 
    void pushdown(int n)
    {
        if(n == 0) return;
        if(node[n].add){
            if(ls(n)){
                node[ls(n)].v += node[n].add;
                node[ls(n)].maxn += node[n].add;
                node[ls(n)].add += node[n].add;
            }
            if(rs(n)){
                node[rs(n)].v += node[n].add;
                node[rs(n)].maxn += node[n].add;
                node[rs(n)].add += node[n].add;
            }
            node[n].add = 0;
        }
        if(node[n].flip){
            if(ls(n)) node[ls(n)].flip ^= 1;
            if(rs(n)) node[rs(n)].flip ^= 1;
            swap(ls(n),rs(n));
            node[n].flip = 0;
        }
    }
    //旋转 
    void rotate(int n,int d)
    {
        int fn = node[n].fa;
        int ffn = node[fn].fa;
        node[fn].ch[d^1] = node[n].ch[d];
        node[node[n].ch[d]].fa = fn;

        node[n].ch[d] = fn;
        node[fn].fa = n;

        node[ffn].ch[rs(ffn)==fn] = n;
        node[n].fa = ffn;
        pushup(fn);
    }
    //将结点n转到goal下 
    void splay(int n,int goal)
    {
        while(node[n].fa != goal)
        {
            int fn = node[n].fa;
            int ffn = node[fn].fa;
            pushdown(ffn),pushdown(fn),pushdown(n);
            bool d = (ls(fn)==n);
            bool d1 = (ls(ffn)==fn);
            if(ffn == goal) rotate(n,d);
            else
            {
                if(d == d1) rotate(fn,d1); else rotate(n,d);
                rotate(n,d1);
            }
        }
        pushup(n);
        if(goal == 0) root = n;
    }
    //找寻中序遍历中的第pos个结点 
    int select(int pos) 
    {
        int u = root;
        pushdown(u);
        while(node[ls(u)].s != pos)
        {
            if(pos < node[ls(u)].s) u = ls(u);
            else
            {
                pos -= node[ls(u)].s + 1;
                u = rs(u);
            }
            pushdown(u);
        }
        return u;
    }
    //查询l~r最大值 
    int query(int l,int r)
    {
        int u = select(l-1),v = select(r+1);
        splay(u,0);splay(v,u);
        return node[ls(v)].maxn;
    }
    //给l~r加上val 
    void update(int l,int r,int val)
    {
        int u = select(l-1),v = select(r+1);
        splay(u,0);splay(v,u);
        node[ls(v)].v += val;
        node[ls(v)].maxn += val;
        node[ls(v)].add += val;
    }
    //翻转l~r 
    void reverse(int l,int r)
    {
        int u = select(l-1),v = select(r+1);
        splay(u,0);splay(v,u);
        node[ls(v)].flip ^= 1;
    }
    //类似二分来建树，就是这段代码现在的我还不会用指针来替换 
    int build(int l,int r)
    {
        if(l > r) return 0;
        if(l == r) return l;
        int mid = (l+r)>>1;
        int L,R;
        ls(mid) = L = build(l,mid-1);
        rs(mid) = R = build(mid+1,r);
        node[L].fa = node[R].fa = mid;
        pushup(mid);
        return mid;
    }
    //初始化 
    void init(int n)
    {
        node[0].init(-INF);node[0].s = 0;
        node[1].init(-INF);
        node[n+2].init(-INF);
        for(int i = 2;i <= n+2;i++)
            node[i].init(0);
        root = build(1,n+2);
        node[root].fa = node[0].fa = 0;
        ls(0) = root;
    }
}splay_tree;

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    splay_tree.init(n);
    for(int i = 0;i < m;i++)
    {
        int opt,l,r,v;
        scanf("%d%d%d",&opt,&l,&r);
        if(opt == 1){scanf("%d",&v);splay_tree.update(l,r,v);}
        if(opt == 2) splay_tree.reverse(l,r);
        if(opt == 3) printf("%d\n",splay_tree.query(l,r));
    }
    return 0;
}

穷尽我对splay理解和借鉴所得到的最适合“我”的代码。