POJ 3580 (伸展树)

题目链接: http://poj.org/problem?id=3580

题目大意：对一个序列进行以下六种操作。输出MIN操作的结果。

解题思路：

六个操作，完美诠释了伸展树有多么吊。注意，默认使用Lazy标记，在pushdown中维护。

ADD操作：为x~y元素加一个d值。首先用split切出x~y元素。然后改变给切出的root->add，root->min，root->v。再merge进原序列。

REVERSE操作：把x~y元素反转。首先用split切出x~y元素，然后改变root->flip标记。再merge进原序列。

REVOLVE操作：把x~y元素偏移T位。注意T可以为负。负向左，正向右。

首先对T进行修正。T=(T%(r-l+1)+(r-l+1))%(r-l+1))，参考自cxlove大神，这样正负方向就一致了，而且解决了没必要的偏移。

这样问题就转化为把[x,y]序列变成left+[y-T+1,y]+[x,y-T]+right，同样参考自cxlove大神。

那么只要split出[x,y-T]就行了。注意T=0时要特判，不然等于切了个0空间，程序就爆了。

INSERT操作：在第x元素后插入P。首先切出[1,x],然后merge这个新的P元素,再merge右段。

注意一下，虽然伸展树是意义上的BST，但是伸展树一旦为了维护原有序列顺序，则可以不再遵循BST的左<=中<=右原则。

这里的INSERT就是，把P元素merge到右边是防止BST维护改变顺序（merge只对left进行BST维护）。

DELETE操作：切出左右两段，merge即可。

MIN操作：求x~y元素最小值。依赖于pushup(也就是maintain)，每次变动都要维护root-v，root->left,root->right三部分的最小值。

首先切出[x,y]，root->minn就是结果。

额外吐槽一下build操作，首先在0号位置加一个inf大的前置结点，这样就可以split出[x,y]这个段了，如果没有前置结点，则应该这么切[1,x-1],当x=1时就完蛋了。

build(0,n)。这样0号点就被放在了最左边。build的时候为了保持原序列顺序，根据位置进行二分build。在最初把伸展树的高度给压下去。

因为伸展树的平衡性能实在太差，如果build成链，那么就要完蛋啦。

#include "cstdio"
#include "cstdlib"
#include "time.h"
#include "queue"
#include "vector"
#include "cstring"
using namespace std;
struct node
{
    node *ch[];
    long long v,s,minn,flip,add;
    node() {s=flip=add=;minn=<<;}
    void maintain()
    {
        s=;
        s+=ch[]->s;
        s+=ch[]->s;
        minn=min(v,min(ch[]->minn,ch[]->minn));
    }
    void push_down()
    {
        if(flip)
        {
            flip = ;
            swap(ch[], ch[]);
            ch[]->flip = !ch[]->flip;
            ch[]->flip = !ch[]->flip;
        }
        if(add)
        {
            ch[]->add+=add;ch[]->add+=add;
            ch[]->v+=add;ch[]->v+=add;
            ch[]->minn+=add;ch[]->minn+=add;
            add=;
        }
    }
    int cmp(int x)
    {
        int d = x-ch[]->s;
        if(d == ) return -;
        return d <=  ?  : ;
    }
};
node *null=new node();
node *root;
node *left,*mid,*right,*oo;
vector<int> ans;
long long arr[];
void rotate(node* &o,int d)
{
    node *k=o->ch[d^];o->ch[d^]=k->ch[d];k->ch[d]=o;
    o->maintain();k->maintain();
    o=k;
}
void splay(node* &o,int k)
{
    o->push_down();
    int d=o->cmp(k);
    if(d==) k-=o->ch[]->s+;
    if(d!=-)
    {
        node *p=o->ch[d];
        p->push_down();
        int d2=p->cmp(k);
        if(d2!=-)
        {
            int k2=(d2==?k:k-p->ch[]->s-);
            splay(p->ch[d2],k2);
            if(d==d2) rotate(o,d^);else rotate(o->ch[d],d);
        }
        rotate(o,d^);
    }
}
node *merge(node* left,node *right)
{
    splay(left,left->s);
    left->ch[]=right;
    left->maintain();
    return left;
}
void split(node *o, int k, node *&left, node *&right)
{
    splay(o, k);
    left = o;
    right = o->ch[];
    o->ch[] = null;
    left->maintain();
}
void build(int l,int r,node* &o)
{
    if(l>r) return;
    int mid=(l+r)>>;
    o=new node;o->v=arr[mid];o->minn=arr[mid];o->s=;o->ch[]=o->ch[]=null;
    build(l,mid-,o->ch[]);
    build(mid+,r,o->ch[]);
    o->maintain();
}
void INSERT(int x,int v)
{
    split(root,x+,left,oo);
    node *tt=new node;
    tt->v=v;tt->s=;tt->minn=v;tt->ch[]=tt->ch[]=null;
    root=merge(merge(left,tt),oo);
}
void DELETE(int x)
{
    split(root,x,left,oo);
    split(oo,,mid,right);
    root=merge(left,right);
}
void MIN(int a,int b)
{
    split(root,a,left,oo);
    split(oo,b-a+,mid,right);
    printf("%lld\n",mid->minn);
    root=merge(merge(left,mid),right);
}
void REVOLVE(int a,int b,int c)
{
    if(!c) return;
    node *tt;
    split(root,a,left,oo);
    split(oo,b-a+,mid,right); //切出[a,b]
    split(mid,b-c-a+,tt,oo);//切出[a,b-c]
    tt=merge(oo,tt);//合并即可
    root=merge(merge(left,tt),right);
}
void ADD(int a,int b,int c)
{
    //切出[a,b]
    if(!c) return;
    split(root,a,left,oo);
    split(oo,b-a+,mid,right);
    mid->add+=c;
    mid->v+=c;
    mid->minn+=c;
    root=merge(merge(left,mid),right);
}
void REVERSE(int a,int b)
{
    split(root,a,left,oo);
    split(oo,b-a+,mid,right);
    mid->flip^=;
    root=merge(merge(left,mid),right);
}
int main()
{
    //freopen("0.in","r",stdin);
    //freopen("0.out","w",stdout);
    int n,m,l,r,x;
    char cmd[];
    arr[]=<<;//前置结点防止干扰
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=;i<=n;i++)
            scanf("%lld",&arr[i]);
        build(,n,root);
        scanf("%d",&m);
        while(m--)
        {
            scanf("%s",cmd);
            if(!strcmp(cmd,"ADD"))
            {
                scanf("%d%d%d",&l,&r,&x);
                ADD(l,r,x);
            }
            if(!strcmp(cmd,"REVERSE"))
            {
                scanf("%d%d",&l,&r);
                REVERSE(l,r);
            }
            if(!strcmp(cmd,"REVOLVE"))
            {
                scanf("%d%d%d",&l,&r,&x);
                REVOLVE(l,r,(x%(r-l+)+(r-l+))%(r-l+));
            }
            if(!strcmp(cmd,"INSERT"))
            {
                scanf("%d%d",&l,&x);
                INSERT(l,x);
            }
            if(!strcmp(cmd,"DELETE"))
            {
                scanf("%d",&l);
                DELETE(l);
            }
            if(!strcmp(cmd,"MIN"))
            {
                scanf("%d%d",&l,&r);
                MIN(l,r);
            }
        }
        root=left=right=oo=null;
    }
}

13476518

neopenx

3580

Accepted

8680K

1047MS

C++

4510B

2014-09-25 17:10:36