poj 3580 SuperMemo (Splay)

版权声明：本文为博主原创文章，未经博主允许不得转载。

poj 3580

好恶心的题目，真是各种操作都来了个遍 。。。

不过Splay树真是一种神奇的东西，通过旋转就能实现各种操作，而且方法也都相差不大 。

题意：

　　给出一个数字序列，有6种操作：

　　　　（1） ADD x y d： 第x个数到第y个数加d 。

　　　　（2） REVERSE x y ： 将区间[x,y]中的数翻转 。 

　　　　（3） REVOLVE x y t ：将区间[x,y]旋转t次，如1 2 3 4 5 旋转2次后就变成4 5 1 2 3 。

　　　　（4） INSERT x p ：在第x个数后面插入p 。

　　　　（5）DELETE x ：删除第x个数 。

　　　　（6） MIN x y ： 查询区间[x,y]中的最小值 。

解法：

　　关于第三点，一开始想难道是一个数一个数从后面取出放到最前面？但这样复杂度太大 。后来仔细一想，既然一个数一个数弄可以，为啥不直接切出一个区间放到最前面呢，然后，就没有然后了 。。。

　　注意t可能很大，所以要先取模 。（至于有没有可能出现负数，我是没试过，反正做了处理就是了 。。。）

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <map>
#define ll long long

using namespace std;

const int N=200000+7;
const int INF=0x3f3f3f3f;

struct tree{
    int key,size,fa,MIN,add,son[2];
    bool flag;
}t[N];
int tot,root;


inline void vis(int x){  // Debug
    if (!x) return;
    printf("节点:%2d : 左儿子 %2d 右儿子 %2d  key值 %2d  size值 %2d filp: %d\n",x,t[x].son[0],t[x].son[1],t[x].key,t[x].size,t[x].flag);
    printf("节点:%2d : 最小值 %2d \n",x,t[x].MIN);
    vis(t[x].son[0]);
    vis(t[x].son[1]);
}

int A[N];
int n;

inline void pushup(int x){
    t[x].size=t[t[x].son[0]].size+t[t[x].son[1]].size+1;
    t[x].MIN=t[x].key;
    if (t[x].son[0]) 
        t[x].MIN=min(t[x].MIN,t[t[x].son[0]].MIN);
    if (t[x].son[1])
        t[x].MIN=min(t[x].MIN,t[t[x].son[1]].MIN);
}

inline void pushdown(int x){
    if (t[x].flag){
        t[x].flag=false;
        swap(t[x].son[0],t[x].son[1]);
        t[t[x].son[0]].flag^=1;
        t[t[x].son[1]].flag^=1;
    }

    if (t[x].add>0){
        if (t[x].son[0]){
            t[t[x].son[0]].key+=t[x].add;
            t[t[x].son[0]].add+=t[x].add;
            t[t[x].son[0]].MIN+=t[x].add;
        }
        if (t[x].son[1]){
            t[t[x].son[1]].key+=t[x].add;
            t[t[x].son[1]].add+=t[x].add;
            t[t[x].son[1]].MIN+=t[x].add;
        }
        t[x].add=0;
    }
}

inline void rotate(int x,int p){
    int y=t[x].fa;
    pushdown(y);
    pushdown(x);
    t[y].son[!p]=t[x].son[p];
    t[t[x].son[p]].fa=y;
    t[x].fa=t[y].fa;
    if (t[x].fa)
        t[t[x].fa].son[t[t[x].fa].son[1]==y]=x;
    t[x].son[p]=y;
    t[y].fa=x;
    pushup(y);
    pushup(x);
}

inline void Splay(int x,int to){
    while (t[x].fa!=to){
        if (t[t[x].fa].fa==to)
            rotate(x,t[t[x].fa].son[0]==x);
        else {
            int y=t[x].fa,z=t[y].fa;
            int p=(t[z].son[0]==y);
            if (t[y].son[p]==x)
                rotate(x,!p),rotate(x,p);
            else 
                rotate(y,p),rotate(x,p);
        }
    }
    if (to==0) root=x;
}

inline int newnode(int key,int fa){
    ++tot;
    t[tot].key=key;
    t[tot].fa=fa;
    t[tot].size=1;
    t[tot].MIN=key;
    t[tot].add=0;
    t[tot].flag=false;
    t[tot].son[0]=t[tot].son[1]=0;
    return tot;
}

inline int get_kth(int k){
    int x=root;
    for(;;){
        pushdown(x);
        if (k==t[t[x].son[0]].size+1)
            break;
        if (k>t[t[x].son[0]].size+1){
            k-=t[t[x].son[0]].size+1;
            x=t[x].son[1];
        }
        else 
            x=t[x].son[0];
    }
    return x;
}

inline int bulidtree(int L,int R,int fa){
    if (L>R) return 0;

    int mid=(L+R)>>1,x;
    x=newnode(A[mid],fa);
    t[x].son[0]=bulidtree(L,mid-1,x);
    t[x].son[1]=bulidtree(mid+1,R,x);
    pushup(x);

    return x;
}

inline void add(int L,int R,int d){
    L=get_kth(L);
    R=get_kth(R+2);
    Splay(L,0);
    Splay(R,L);    
    t[t[R].son[0]].key+=d;
    t[t[R].son[0]].MIN+=d;
    t[t[R].son[0]].add+=d;
    pushup(R);
    pushup(L);
}

inline void reverse(int L,int R){
    L=get_kth(L);
    R=get_kth(R+2);
    Splay(L,0);
    Splay(R,L);
    t[t[R].son[0]].flag^=1;
}

inline void revolve(int L,int R,int k){
    k=(k%(R-L+1)+(R-L+1))%(R-L+1);
    if (!k) return;

    int x=get_kth(R-k+1);
    int y=get_kth(R+2);
    Splay(x,0);
    Splay(y,x);
    int tmp=t[y].son[0];
    t[y].son[0]=0; 
    pushup(y);
    pushup(x);

    x=get_kth(L);
    y=get_kth(L+1);
    Splay(x,0);
    Splay(y,x);
    t[y].son[0]=tmp;
    t[tmp].fa=y;
    pushup(y);
    pushup(x);
}

inline void insert(int x,int p){
    Splay(get_kth(x+1),0);
    Splay(get_kth(x+2),root);
    t[t[root].son[1]].son[0]=newnode(p,t[root].son[1]);
    pushup(t[root].son[1]);
    pushup(root);
}

inline void del(int x){
    Splay(get_kth(x),0);
    Splay(get_kth(x+2),root);
    t[t[root].son[1]].son[0]=0;
    pushup(t[root].son[1]);
    pushup(root);
}

inline int query(int L,int R){
    int x=get_kth(L);
    int y=get_kth(R+2);
    Splay(x,0);
    Splay(y,x);
    return t[t[y].son[0]].MIN;
}

int main(){
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",&A[i]);
    A[0]=A[n+1]=INF;

    root=bulidtree(0,n+1,0);
    // 由于取点的时候很多是取该点的前一个点或者后一个点，所以要加多两个虚节点

    int m,x,y,z;
    char ch[20];
    scanf("%d",&m);
    while (m--){
        scanf("%s",ch);
        switch (ch[0]){
            case 'A':
                scanf("%d %d %d",&x,&y,&z);
                add(x,y,z);
                break;
            case 'R':
                if (ch[3]=='E') {
                    scanf("%d %d",&x,&y);
                    reverse(x,y);
                }
                else {
                    scanf("%d %d %d",&x,&y,&z);
                    revolve(x,y,z);
                }
                break;
            case 'I':
                scanf("%d %d",&x,&y);
                insert(x,y);
                break;
            case 'D':
                scanf("%d",&x);
                del(x);
                break;
            case 'M':
                scanf("%d %d",&x,&y);
                printf("%d\n",query(x,y));
                break;
        }
    }

    return 0;
}