hdu4453Looploop(splay)

题目请戳这里

题目大意：给一个数字串，长度n，首尾相连的。有一个对序列操作的指针，初始指向第一个数字。给m个操作，2个参数k1，k2。给6种操作：

1：add x，在当前指针所在位置顺时针方向的k2个数字，每个数字加x。

2：reverse，从当前指针所在位置开始顺时针方向k1个数字翻转。

3：insert x，当前指针下一个位置加上一个x。

4：delete，删除当前指针所在位置元素。

5：move x，x=1的时候指针逆时针移动一个位置，x=2的时候指针顺时针移动一个位置。

6：query，查询当前指针所指的元素值。

题目的插图也很明白。

题目分析：splay的基本操作。具体实现：

1，每个节点维护一个累加值，延时标记。

2，每个节点维护一个翻转标记，延时标记。因为是环状的，所以可能要分2部分，解决方法是如果尾部不够，将序列头部剪切一段到尾部，凑齐再翻转。

3，略

4，删除很简单，注意删除后记得检查指针位置是否合法，因为是环状的，可能要移动到序列最左端。

5，略

6，。。。

代码又写的比较长，将就着看吧=_=!!。。。。

详情请见代码：

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 1000005;
const int inf = 0x3f3f3f3f;

int next[N + N];
struct node
{
    int l,r,f,add,lazy,key,size;
}tree[N + N];
int n,m,k1,k2;
void init()
{
    tree[0].size = tree[0].l = tree[0].r = tree[0].f = 0;
    tree[0].add = tree[0].key = tree[0].lazy = 0;
    int nn = N + N;
    for(int i = 0;i < nn;i ++)
        next[i] = i + 1;
}
int newnode()
{
    int p = next[0];
    next[0] = next[p];
    tree[p].lazy = tree[p].add = 0;
    tree[p].l = tree[p].r = tree[p].f = 0;
    tree[p].size = 1;
    return p;
}
void delnode(int p)
{
    next[p] = next[0];
    next[0] = p;
}
void pushup(int rt)
{
    if(rt)
    {
        tree[rt].size = tree[tree[rt].l].size + tree[tree[rt].r].size + 1;
    }
}
void pushdown(int rt)
{
    if(!rt)
        return;
    int ls = tree[rt].l;
    int rs = tree[rt].r;
    if(tree[rt].add)
    {
        if(ls)
        {
            tree[ls].add += tree[rt].add;
            tree[ls].key += tree[rt].add;
        }
        if(rs)
        {
            tree[rs].add += tree[rt].add;
            tree[rs].key += tree[rt].add;
        }
        tree[rt].add = 0;
    }
    if(tree[rt].lazy)
    {
        swap(tree[rt].l,tree[rt].r);
        if(ls)
            tree[ls].lazy ^= 1;
        if(rs)
            tree[rs].lazy ^= 1;
        tree[rt].lazy = 0;
    }
}
void zig(int x)
{
    int p = tree[x].f;
    pushdown(p);
    pushdown(x);
    tree[p].l = tree[x].r;
    if(tree[x].r)
        tree[tree[x].r].f = p;
    pushup(p);
    tree[x].r = p;
    tree[x].f = tree[p].f;
    pushup(x);
    tree[p].f = x;
    if(tree[x].f == 0)
        return;
    if(tree[tree[x].f].l == tree[x].r)
        tree[tree[x].f].l = x;
    else
        tree[tree[x].f].r = x;
}
void zag(int x)
{
    int p = tree[x].f;
    pushdown(p);
    pushdown(x);
    tree[p].r = tree[x].l;
    if(tree[x].l)
        tree[tree[x].l].f = p;
    pushup(p);
    tree[x].l = p;
    tree[x].f = tree[p].f;
    pushup(x);
    tree[p].f = x;
    if(tree[x].f == 0)
        return;
    if(tree[tree[x].f].l == tree[x].l)
        tree[tree[x].f].l = x;
    else
        tree[tree[x].f].r = x;
}
int splay(int x,int goal)
{
    pushdown(x);
    int p;
    while(tree[x].f != goal)
    {
        p = tree[x].f;
        int g = tree[p].f;
        if(g == goal)
        {
            if(tree[p].l == x)
                zig(x);
            if(tree[p].r == x)
                zag(x);
        }
        else
        {
            if(tree[g].l == p && tree[p].l == x)
                zig(p),zig(x);
            else if(tree[g].l == p && tree[p].r == x)
                    zag(x),zig(x);
                else if(tree[g].r == p && tree[p].r == x)
                        zag(p),zag(x);
                    else if(tree[g].r == p && tree[p].l == x)
                            zig(x),zag(x);
        }
    }
    pushup(x);
    return x;
}
int build(int s,int e,int fa)
{
    if(s > e)
        return 0;
    int mid = (s + e)>>1;
    int p = newnode();
    tree[p].l = build(s,mid - 1,p);
    scanf("%d",&tree[p].key);
    tree[p].f = fa;
    tree[p].r = build(mid + 1,e,p);
    pushup(p);
    return p;
}
int getmin(int rt)
{
    pushdown(rt);
    while(tree[rt].l)
    {
        rt = tree[rt].l;
        pushdown(rt);
    }
    return rt;
}
int getmax(int rt)
{
    pushdown(rt);
    while(tree[rt].r)
    {
        rt = tree[rt].r;
        pushdown(rt);
    }
    return rt;
}
int find(int pos,int rt)
{
    if(!rt)
        return 0;
    pushdown(rt);
    if(tree[tree[rt].l].size == pos - 1)
        return rt;
    if(tree[tree[rt].l].size >= pos)
        return find(pos,tree[rt].l);
    else
        return find(pos - tree[tree[rt].l].size - 1,tree[rt].r);
}
void prepare(int &root)
{
    root = newnode();
    tree[root].key = inf;
    tree[root].r = newnode();
    tree[tree[root].r].key = inf;
    tree[tree[root].r].f = root;
    tree[tree[root].r].l = build(1,n,tree[root].r);
    pushup(tree[root].r);
    pushup(root);
    int tmp = getmin(tree[tree[root].r].l);
    root = splay(tmp,0);
}
void Rotate_interval(int a,int b,int &root)
{
    int l = find(a,root);
    int r = find(b + 2,root);
    root = splay(l,0);
    tree[root].r = splay(r,root);
    pushup(tree[root].r);
    pushup(root);
}
void Add(int x,int &root)
{
    int rt,a,b,lefta = 0;
    rt = root;
    if(tree[tree[root].r].size < k2)
        lefta = k2 - tree[tree[root].r].size;
    if(lefta)
    {
        a = tree[tree[root].l].size;
        b = tree[root].size - 2;
        Rotate_interval(a,b,root);
        tree[tree[tree[root].r].l].add += x;
        tree[tree[tree[root].r].l].key += x;
        a = 1;
        b = a + lefta - 1;
        Rotate_interval(a,b,root);
        tree[tree[tree[root].r].l].add += x;
        tree[tree[tree[root].r].l].key += x;
    }
    else
    {
        a = tree[tree[root].l].size;
        b = a + k2 - 1;
        Rotate_interval(a,b,root);
        tree[tree[tree[root].r].l].add += x;
        tree[tree[tree[root].r].l].key += x;
    }
    root = splay(rt,0);
}
void Reverse(int &root)
{
    int a,b,rt,lefta = 0;
    int lsize = tree[tree[root].l].size;
    if(tree[tree[root].r].size < k1)
        lefta = k1 - tree[tree[root].r].size;
    if(lefta)
    {
        a = 1;
        b = lefta;
        Rotate_interval(a,b,root);
        tree[tree[tree[root].r].l].lazy ^= 1;
        a = lefta + 1;
        b = tree[root].size - 2;
        Rotate_interval(a,b,root);
        tree[tree[tree[root].r].l].lazy ^= 1;
        a = 1;b = tree[root].size - 2;
        Rotate_interval(a,b,root);
        tree[tree[tree[root].r].l].lazy ^= 1;
    }
    a = lsize - lefta;
    b = a + k1 - 1;
    Rotate_interval(a,b,root);
    tree[tree[tree[root].r].l].lazy ^= 1;
    rt = find(lsize - lefta + 1,root);
    root = splay(rt,0);
}
void Insert(int x,int &root)
{
    int a = getmin(tree[root].r);
    tree[root].r = splay(a,root);
    int p = newnode();
    tree[p].key = x;
    tree[p].f = tree[root].r;
    tree[tree[root].r].l = p;
    pushup(tree[root].r);
    pushup(root);
}
void Delete(int &root)
{
    int a = getmin(tree[root].r);
    tree[root].r = splay(a,root);
    int p = root;
    tree[tree[root].r].f = 0;
    tree[tree[root].l].f = tree[root].r;
    tree[tree[root].r].l = tree[root].l;
    root = tree[root].r;delnode(p);
    if(tree[root].r == 0)
    {
        a = find(2,root);
        root = splay(a,0);
    }
    pushup(root);
}
void Move(int x,int &root)
{
    int tmp;
    if(x == 1)
    {
        if(tree[tree[root].l].size > 1)
            tmp = getmax(tree[root].l);
        else
            tmp = find(tree[root].size - 1,root);
    }
    else
    {
        if(tree[tree[root].r].size > 1)
            tmp = getmin(tree[root].r);
        else
            tmp = find(2,root);
    }
    root = splay(tmp,0);
}
void Query(int &root)
{
    printf("%d\n",tree[root].key);
}
int main()
{
    int x,cas = 0;
    int root;
    char op[20];
    init();
    while(scanf("%d",&n),n)
    {
        scanf("%d%d%d",&m,&k1,&k2);
        prepare(root);
        printf("Case #%d:\n",++cas);
        while(m --)
        {
            scanf("%s",op);
            switch(*op)
            {
            case 'a':scanf("%d",&x);Add(x,root);break;
            case 'r':Reverse(root);break;
            case 'i':scanf("%d",&x);Insert(x,root);break;
            case 'd':Delete(root);break;
            case 'm':scanf("%d",&x);Move(x,root);break;
            case 'q':Query(root);break;
            }
        }
    }
    return 0;
}
//218MS	14960K