POJ 3580 FHQ_Treap平衡树

题目链接

题意：

给一个长度为n的数组，初始为a1,...,an

需要维护以下操作：

ADD l r x：给区间[l,r]上的所有元素+x

REVERSE l r：反转区间[l,r]（比如：[1,2,3]反转后变成[3,2,1]）

REVOLVE l r x：将区间[l,r]向前循环右移x位（比如：[1,2,3]循环右移2位变成[2,3,1]）

INSERT P x：在位置P后插入一个x（比如：[1,2,3]在位置2后插入一个4变成[1,2,4,3]）

DELETE P：删除位置P上的元素

MIN l r：求区间[l,r]的最小值

思路：

FHQ_Treap平衡树多操作合集

C++代码：

#include<map>
#include<set>
#include<stack>
#include<cmath>
#include<queue>
#include<vector>
#include<string>
#include<cstdio>
#include<cstring>
#include<complex>
#include<iostream>
#include<algorithm>
using namespace std;
#define ls ftr[k].l
#define rs ftr[k].r
typedef double DB;
typedef long long LL;
typedef complex<double>CD;
const int maxn = 200010;
const int mod = 1e9+7;
const int inf = 0x3f3f3f3f;

void Mod( int &x ){ x%=mod; }
int Min( int a , int b ){ return a<b?a:b; }
int Max( int a , int b ){ return a>b?a:b; }
int Random(){ static int seed = 703; return seed=(int)(seed*48271LL%2147483647); }

int root,sizes;

struct FHQ_Treap
{
    int l,r;
    int v,rnd;
    int sizes;
    int minx,rev,cnt;
}ftr[maxn];

void Addone( int k , int s )
{
    if ( !k )
        return;
    ftr[k].v += s;
    ftr[k].cnt += s;
    ftr[k].minx += s;
}

void Revone( int k )
{
    if ( !k )
        return;
    ftr[k].rev ^= 1;
    swap ( ls , rs );
}

void Push_up( int k )
{
    if ( !k )
        return;
    ftr[k].minx = Min ( ftr[k].v , Min( ftr[ls].minx , ftr[rs].minx ) );
    ftr[k].sizes = ftr[ls].sizes+ftr[rs].sizes+1;
}

void Push_down( int k )
{
    if ( !k )
        return;
    if ( ftr[k].cnt )
        Addone( ls , ftr[k].cnt ),Addone( rs , ftr[k].cnt );
    if ( ftr[k].rev )
        Revone( ls ),Revone( rs );
    ftr[k].cnt = 0;
    ftr[k].rev = 0;
}

void Build( int &k , int s )
{
    k = ++sizes;
    ftr[k].l = 0;
    ftr[k].r = 0;
    ftr[k].v = s;
    ftr[k].rnd = Random();
    ftr[k].sizes = 1;
    ftr[k].minx = s;
    ftr[k].rev = 0;
    ftr[k].cnt = 0;
}

void Split( int k , int &l , int &r , int s )
{
    if ( s==0 )
        l = 0,r = k;
    else if ( s==ftr[k].sizes )
        l = k,r = 0;
    else if ( s<=ftr[ls].sizes )
        Push_down( r=k ),Split( ls , l , ls , s ),Push_up( k );
    else
        Push_down( l=k ),Split( rs , rs , r , s-ftr[ls].sizes-1 ),Push_up( k );
}

void Merge( int &k , int l , int r )
{
    if ( l==0||r==0 )
        k = l+r;
    else if ( ftr[l].rnd<ftr[r].rnd )
        Push_down( k=l ),Merge( rs , rs , r ),Push_up( k );
    else
        Push_down( k=r ),Merge( ls , l , ls ),Push_up( k );
}

void Add( int l , int r , int s )
{
    int x,y,z;
    Split( root , x , y , r );
    Split( x , z , x , l-1 );
    Addone( x , s );
    Merge( x , z , x );
    Merge( root , x , y );
}

void Reverse( int l , int r )
{
    int x,y,z;
    Split( root , x , y , r );
    Split( x , z , x , l-1 );
    Revone( x );
    Merge( x , z , x );
    Merge( root , x , y );
}

void Revolve( int l , int r , int s )
{
    int x,y,z,h;
    Split( root , x , y , r-s );
    Split( x , z , x , l-1 );
    Split( y , y , h , s );
    Merge( x , y , x );
    Merge( x , z , x );
    Merge( root , x , h );
}

void Insert( int k , int s )
{
    int x,y;
    Split( root , x , y , k );
    Merge( x , x , s );
    Merge( root , x , y );
}

void Delete( int s )
{
    int x,y,z;
    Split( root , x , y , s );
    Split( x , x , z , s-1 );
    Merge( root , x , y );
}

int Query( int l , int r )
{
    int x,y,z,ans;
    Split( root , x , y , r );
    Split( x , z , x , l-1 );
    ans = ftr[x].minx;
    Merge( x , z , x );
    Merge( root , x , y );
    return ans;
}

int main()
{
    for ( int n,m ; scanf ( "%d" , &n )==1 ; )
    {
        ftr[0].minx = inf;
        sizes = root = 0;
        for ( int i=1,x,t ; i<=n ; i++ )
        {
            scanf ( "%d" , &x );
            Build ( t , x );
            Merge ( root , root , t );
        }
        scanf ( "%d" , &m );
        for ( int i=1 ; i<=m ; i++ )
        {
            char s[15];
            int x,y,z;
            scanf ( "%s" , s );
            if ( s[0]=='A' )
            {
                scanf ( "%d%d%d" , &x , &y , &z );
                Add( x , y , z );
            }
            else if ( s[0]=='M' )
            {
                scanf ( "%d%d" , &x , &y );
                printf ( "%d\n" , Query( x , y ) );
            }
            else if ( s[0]=='R'&&s[3]=='E' )
            {
                scanf ( "%d%d" , &x , &y );
                Reverse ( x , y );
            }
            else if ( s[0]=='R'&&s[3]=='O' )
            {
                scanf ( "%d%d%d" , &x , &y , &z );
                Revolve ( x , y , z%(y-x+1) );
            }
            else if ( s[0]=='I' )
            {
                scanf ( "%d%d" , &x , &y );
                Build ( z , y );
                Insert ( x , z );
            }
            else if ( s[0]=='D' )
            {
                scanf ( "%d" , &x );
                Delete ( x );
            }
        }
    }
    return 0;
}