hdu 4453 Looploop（splay）

hdu4454Looploop

一看到有旋转操作就splay了

做两个lazy标记： flip（旋转）， add（增加）

六种操作

增加，删除，旋转，插入，移动，查询

1.add增加：add（x） 对前k2个数字增加x

将从箭头指向位置开始前k2个节点从树中分离，分离出来的根节点add+x，再将两棵树合并 

2.reverse旋转：  将前k1个数字颠倒过来

将从箭头指向位置开始前k1个节点从书中分离，分离出来的根节点flip=1， 再将两棵树合并

3.insert插入： insert(x) 在箭头指向位置的后面插入一个x

将指向位置伸展为树根，那么其他所有的节点都在根的右孩子，在根与根的右孩子前插入x即可，节点数n+1

4.delete删除：将箭头指向位置的数字删除，箭头顺时针移动一个位置（右移/后移）

将指向位置伸展为树根，那么其他所有的节点都在根的右孩子，将树根删除，将原树根右孩子设为新根，节点数n-1

5.move移动：move(x), x=1箭头逆时针移动（左移/前移），x=2箭头顺时针移动（右移/后移）

x=1 将n位置的节点从树中分离，将原根设为其右孩子：root=splay（n），root->child[1]=splay(1)；

x=2与此类似

6.query查询：输出箭头指向位置的数字

将指向位置伸展为树根，root=splay（1），output：root->value

 ===========================================================

刚开始new节点，果断超时，后来开了数组，newnode(int) 替换new node(int)

node lk[maxn];
int cnt;
node* newnode(int v)
{
    lk[cnt]=node(v);
    return lk+cnt++;
}

build(root, 1, N);
cnt=0;

一直是运行出错调试了一上午 = = 。。。。。。。飙泪

最后发现cnt出了问题，竟然sb的build之后cnt=0.。。

代码如下： 343ms

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
const int maxn = 2e5+5;
int N, M, K1, K2;

int hdu[maxn];
struct node
{
    node *child[2];
    int size;
    int value;
    int flip;
    int add;
    node ();
    node(int);
    void pushup();
    void pushdown();
    int rank();
    int cmp(int k);
}null, *root, lk[maxn];
int cnt;
node* newnode(int v)
{lk[cnt]=node(v);
    return lk+cnt++;
}
int node:: cmp(int k)
{
    if(k==rank()) return -1;
    return k < rank() ? 0 : 1;
}
int node:: rank()
{
    return child[0]->size+1;
}
void node:: pushdown()
{

    if(flip)
    {
        swap(child[0], child[1]);
        child[0]->flip^=1;
        child[1]->flip^=1;
        flip=0;
    }
    if(add)
    {
        value+=add;
        child[0]->add+=add;
        child[1]->add+=add;
        add=0;
    }
}
void node:: pushup()
{
    size=child[0]->size+child[1]->size+1;
}
node:: node()
{
    child[0]=child[1]=&null;
    size=0;
    flip=0;
    add=0;
}
node:: node(int _value): value(_value)
{
    child[0]=child[1]=&null;
    size=1;
    flip=0;
    add=0;
}
void rotate(node*&o, int d)
{
    o->pushdown();
    node *t=o->child[d];
    t->pushdown();
    o->child[d]=t->child[d^1];
    t->child[d^1]=o;
    o->pushup();
    o=t;
    o->pushup();
}
void splay(node*& o, int k)
{
    o->pushdown();
    int d=o->cmp(k);
    if(~d)
    {
        if(d) splay(o->child[d], k-o->rank());
        else splay(o->child[d], k);
        rotate(o, d);
    }
}
void build(node*&o, int l ,int r)
{
    int m= (l+r)>>1;
    o=newnode(hdu[m]);

    if(m>l) build(o->child[0], l, m-1);
    if(m<r) build(o->child[1], m+1, r);

    o->pushup();
}

void add(int x)
{
    splay(root, K2);
    root->value+=x;
    root->child[0]->add+=x;
}
void reverse()
{
    splay(root, K1);

    node*temp=root->child[1];
    root->child[1]=&null;
    root->pushup();

    root->flip=1;
    root->pushdown();
    splay(root, K1);

    root->child[1]=temp;
    root->pushup();
}
void insert(int x)
{
    splay(root, 1);

    node *temp=newnode(x);
    temp->child[1]=root->child[1];
    temp->pushup();

    root->child[1]=temp;
    root->pushup();

    N++;
}
void remove()
{
    splay(root, 1);
    node *temp=root->child[1];
    root=temp;
    root->pushdown();

    N--;
}
void move(int x)
{
    if(x==1)
    {
        splay(root, N);
        node *temp = root->child[0];
        root->child[0]=&null;

        temp->pushdown();
        splay(temp, 1);
        root->child[1]=temp;
        root->pushup();
    }
    else
    {
        splay(root, 1);
        node *temp = root->child[1];
        root->child[1]=&null;

        temp->pushdown();
        splay(temp, N-1);
        root->child[0]=temp;
        root->pushup();
    }
}

int main()
{
    int kase=1;
    while(cin>>N>>M>>K1>>K2 && N|M|K1|K2)
    {
        for(int i=1;i<=N;i++) scanf("%d", hdu+i); cnt=0;
        build(root, 1, N);
        printf("Case #%d:\n", kase++);
        while(M--)
        {
            char op1[10]; scanf("%s", op1);
            if(!strcmp(op1, "add"))
            {
                int op2; scanf("%d", &op2);
                add(op2);
            }
            else if(!strcmp(op1, "reverse"))
            {
                reverse();
            }
            else if(!strcmp(op1, "insert"))
            {
                int op2; scanf("%d", &op2);
                insert(op2);
            }
            else if(!strcmp(op1, "delete"))
            {
                remove();
            }
            else if(!strcmp(op1, "move"))
            {
                int op2; scanf("%d", &op2);
                move(op2);
            }
            else
            {
                splay(root, 1);
                printf("%d\n", root->value);
            }
        }
    }
    return 0;
}