NOI2007项链工厂——sbTreap代码

 
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cstdlib>
 
using namespace std;
struct node
{
    int data;
    int left;
    int right;
    int key;
    int size;
    bool turn;
    int ans;
    int mark;
    node* ls,*rs;
    node(int dat=0,int ke=0)
    {
        data=dat;
        key=ke;
        left=data;
        right=data;
        size=1;
        turn=false;
        mark=0;
        ans=1;
        ls=NULL;
        rs=NULL;
    }
}no[500010];
 
 
void pushdown(node* now)
{
    if (now->mark)
    {
        if (now->ls)
        {
            now->ls->data=now->mark;
            now->ls->mark=now->mark;
            now->ls->left=now->mark;
            now->ls->right=now->mark;
            now->ls->ans=1;
        }
        if (now->rs)
        {
            now->rs->data=now->mark;
            now->rs->mark=now->mark;
            now->rs->left=now->mark;
            now->rs->right=now->mark;
            now->rs->ans=1;
        }
        now->mark=0;
    }
    if (now->turn)
    {
        node* l=now->ls;
        node* r=now->rs;
        if (now->ls)
            now->ls->left^=now->ls->right^=now->ls->left^=now->ls->right;
        if (now->rs)
            now->rs->left^=now->rs->right^=now->rs->left^=now->rs->right;
        now->ls=r;
        now->rs=l;
        if (now->ls) now->ls->turn=!now->ls->turn;
        if (now->rs) now->rs->turn=!now->rs->turn;
        now->turn=false;
    }
}
 
void update(node* now)
{
    now->size=1;
    now->ans=1;
    now->left=now->data;
    now->right=now->data;
    if (now->ls)
    {
        now->size+=now->ls->size;
        now->ans+=now->ls->ans;
        now->left=now->ls->left;
    }
    if (now->rs)
    {
        now->size+=now->rs->size;
        now->ans+=now->rs->ans;
        now->right=now->rs->right;
    }
    if (now->ls)
        if (now->ls->right==now->data) now->ans--;
    if (now->rs)
        if (now->rs->left==now->data) now->ans--;
}
 
node* merge(node* a,node* b)
{
    if (!b) return a;
    if (!a) return b;
    pushdown(a);
    pushdown(b);
    if (a->key<=b->key)
    {
        a->rs=merge(a->rs,b);
        update(a);
        return a;
    }
    else
    {
        b->ls=merge(a,b->ls);
        update(b);
        return b;
    }
}
 
struct npair
{
    node* l,*r;
    npair(node* a,node* b)
    {
        l=a;
        r=b;
    }
};
 
npair split(node* a,int k)
{
    if (!a) return npair(NULL,NULL);
    if (k==0) return npair(NULL,a);
    pushdown(a);
    if (a->ls)
    {
        if (a->ls->size>=k)
        {
            npair km=split(a->ls,k);
            a->ls=km.r;
            update(a);
            return npair(km.l,a);
        }
        else
        {
            npair km=split(a->rs,k-a->ls->size-1);
            a->rs=km.l;
            update(a);
            return npair(a,km.r);
        }
    }
    else
    {
        npair km=split(a->rs,k-1);
        a->rs=km.l;
        update(a);
        return npair(a,km.r);
    }
}
node* insert(node* root,node* newnode)
{
    return merge(root,newnode);
}
 
void turn(node* now)
{
    now->turn=!now->turn;
    now->left^=now->right^=now->left^=now->right;
}
 
node* rotate(node* root,int num)
{
    int n=root->size;
    num=num%n;
    int k=n-num;
    npair km = split(root,k);
    return merge(km.r,km.l);
}
 
node* flip(node* root)
{
    int n=root->size;
    int r;
    if (n%2==1)
    {
        r=n/2+1;
    }
    else
    {
        r=n/2;
    }
    npair km=split(root,r);
    npair km2=split(km.l,1);
    if (n%2==1)
    {
        turn(km2.r);
        turn(km.r);
        return merge(merge(km2.l,km.r),km2.r);
    }
    else
    {
        npair km3=split(km.r,1);
        turn(km2.r);
        turn(km3.r);
        return merge(merge(km2.l,km3.r),merge(km3.l,km2.r));
    }
}
 
node* swap(node* root,int i,int j)
{
    if (i>j) i^=j^=i^=j;
    if (i==j) return root;
    npair km=split(root,i);
    npair km2=split(km.l,i-1);
    npair km3=split(km.r,j-i);
    npair km4=split(km3.l,j-i-1);
    return merge(merge(merge(km2.l,km4.r),km4.l),merge(km2.r,km3.r));
}
 
node* paint(node* root,int i,int j,int x)
{
    int n=root->size;
    if (i<=j)
    {
        npair km=split(root,i-1);
        npair km2=split(km.r,j-i+1);
        km2.l->mark=x;
        km2.l->data=x;
        km2.l->ans=1;
        km2.l->left=x;
        km2.l->right=x;
        return merge(km.l,merge(km2.l,km2.r));
    }
    else
    {
        npair km=split(root,j);
        int nn=km.r->size;
        npair km2=split(km.r,nn-n+i-1);
        km.l->mark=x;
        km.l->data=x;
        km.l->ans=1;
        km.l->left=x;
        km.l->right=x;
        km2.r->mark=x;
        km2.r->data=x;
        km2.r->ans=1;
        km2.r->left=x;
        km2.r->right=x;
        return merge(km.l,merge(km2.l,km2.r));
    }
}
 
node* root;
int countS(int i,int j)
{
    int n=root->size;
    if (i<=j)
    {
        npair km=split(root,i-1);
        npair km2=split(km.r,j-i+1);
        int ret=km2.l->ans;
        root=merge(km.l,merge(km2.l,km2.r));
        return ret;
    }
    else
    {
        npair km=split(root,j);
        int nn=km.r->size;
        npair km2=split(km.r,nn-n+i-1);
        int ret=km.l->ans+km2.r->ans;
        if (km.l->left==km2.r->right) ret--;
        root=merge(km.l,merge(km2.l,km2.r));
        return ret;
    }
}
 
int count()
{
    int ret=root->ans;
    if (root->left==root->right&&ret!=1) ret--;
    return ret;
}
 
void print(node* now,bool b)
{
    if (!now) return;
    b=b^now->turn;
//  if (!b)
        print(now->ls,b);
//  else
//      print(now->rs,b);
    printf("data: %d size: %d mark: %d turn: %d ans: %d left: %d right: %d
",now->data,now->size,now->mark,now->turn,now->ans,now->left,now->right);
//  if (!b)
        print(now->rs,b);
//  else
//      print(now->ls,b);
}
 
void print(node* now)
{
    if (!now) return;
    pushdown(now);
    print(now->ls);
    printf("%d
",now->data);
    print(now->rs);
}
 
int cnt=-1;
int main()
{
    int n,c;
    scanf("%d%d",&n,&c);
    int j;
    for (int i=1;i<=n;++i)
    {
        scanf("%d",&j);
        node* q=&no[++cnt];
        *q=node(j,rand());
        root=insert(root,q);
    }
    int m;
    scanf("%d",&m);
    char cmd[3];
    int l,r,k;
    for (int i=1;i<=m;++i)
    {
        scanf("%s",cmd);
        if (cmd[0]=='R'){scanf("%d",&k);root=rotate(root,k);}
        if (cmd[0]=='F'){root=flip(root);}
        if (cmd[0]=='S'){scanf("%d%d",&l,&r);root=swap(root,l,r);}
        if (cmd[0]=='P'){scanf("%d%d%d",&l,&r,&k);root=paint(root,l,r,k);}
        if (cmd[0]=='C'&&cmd[1]!='S'){printf("%d
",count());}
        if (cmd[0]=='C'&&cmd[1]=='S'){scanf("%d%d",&l,&r);printf("%d
",countS(l,r));}
//           printf("%d
",i);
//      printf("--------------------
");
//      print(root,false);
//      printf("--------------------
");
    }
    return 0;
}