BZOJ 1500 FHQ_Treap平衡树

题目链接

题意：

初始给一个长度为n的数组，维护以下操作：

1.插入一段数字：p tot a1...atot表示在位置p后面插入tot个数字

2.删除一段数字：p tot表示在位置p开始删除tot个数字

3.修改一段数字：p tot c表示在位置p开始修改tot个数字为c

4.反转一段数字：p tot表示将在位置p开始长度为tot的区间反转

5.求和一段数字：p tot表示求从位置p开始长度为tot的区间和

6.求整个数组的最大子列和

思路：

因为插入数字和删除数字比较多，所以考虑单个单个以log的时间复杂度进行插入和删除，必定会超时，所以我们采用以下策略来应对：

1.将数字全部输入“线性建树”建成一颗小树z，将原来的树在p处拆开为x，y，然后合并x，z，y

2.将要删除的数字从树中拆出来单独一颗树z，然后将这些树的“下标回收”

3.将要修改的区间从树中拆出来单独修改

4.将要反转的区间从树中拆出来单独反转

5.将要求和的区间从树中拆出来单独求和

6.Push_up细心维护，和线段区间合并维护最大子列和类似

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 = 500010;
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,a[maxn];
queue<int>Q;

struct FHQ_Treap
{
    int l,r;
    int v,rnd;
    int sizes;
    int sum,rev,cnt;
    int lmax,rmax,maxx;
}ftr[maxn];

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

void Covone( int k , int s )
{
    if ( !k )
        return;
    ftr[k].v = s;
    ftr[k].sum = ftr[k].sizes*s;
    ftr[k].cnt = s;
    ftr[k].lmax = ftr[k].rmax = ftr[k].maxx = Max ( s , s*ftr[k].sizes );
}

void Push_up( int k )
{
    if ( !k )
        return;
    ftr[k].sizes = ftr[ls].sizes+ftr[rs].sizes+1;
    ftr[k].sum = ftr[ls].sum+ftr[rs].sum+ftr[k].v;
    ftr[k].maxx = Max ( Max( 0 , ftr[ls].rmax )+ftr[k].v+Max( 0 , ftr[rs].lmax ) , Max( ftr[ls].maxx , ftr[rs].maxx ) );
    ftr[k].lmax = Max ( ftr[ls].lmax , ftr[ls].sum+ftr[k].v+Max( 0 , ftr[rs].lmax ) );
    ftr[k].rmax = Max ( ftr[rs].rmax , ftr[rs].sum+ftr[k].v+Max( 0 , ftr[ls].rmax ) );
}

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

void Build( int &k , int s )
{
    if ( !Q.empty() )
        k = Q.front(),Q.pop();
    else
        k = ++sizes;
    ftr[k].l = 0;
    ftr[k].r = 0;
    ftr[k].v = s;
    ftr[k].rnd = Random();
    ftr[k].sizes = 1;
    ftr[k].sum = s;
    ftr[k].rev = 0;
    ftr[k].cnt = inf;
    ftr[k].lmax = s;
    ftr[k].rmax = s;
    ftr[k].maxx = s;
}

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 Cov( int l , int r , int s )
{
    int x,y,z;
    Split( root , x , y , r );
    Split( x , z , x , l-1 );
    Covone( x , s );
    Merge( x , z , x );
    Merge( root , x , y );
}

void Rev( 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 );
}

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

void Back( int k )
{
    if ( !k )
        return;
    Back( ls );
    Q.push( k );
    Back( rs );
}

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

void New( int &k , int l , int r )
{
    if ( l>r )
    {
        k = 0;
        return;
    }
    int mid = ( l+r )>>1;
    Build( k , a[mid] );
    New ( ls , l , mid-1 );
    New ( rs , mid+1 , r );
    Push_up( k );
}

int main()
{
    for ( int n,m ; scanf ( "%d%d" , &n , &m )==2 ; )
    {
        ftr[0].maxx = -inf;
        sizes = root = 0;
        for ( int i=1 ; i<=n ; i++ )
            scanf ( "%d" , &a[i] );
        New ( root , 1 , n );
        for ( int i=1 ; i<=m ; i++ )
        {
            char s[15];
            int p,tot,c,x,y;
            scanf ( "%s" , s );
            if ( s[0]=='I' )
            {
                scanf ( "%d%d" , &p , &tot );
                for ( int j=1 ; j<=tot ; j++ )
                    scanf ( "%d" , &a[j] );
                New ( c , 1 , tot );
                Split( root , x , y , p );
                Merge( x , x , c );
                Merge( root , x , y );
            }
            else if ( s[0]=='D' )
            {
                scanf ( "%d%d" , &p , &tot );
                Delete( p , p+tot-1 );
            }
            else if ( s[0]=='M'&&s[2]=='K' )
            {
                scanf ( "%d%d%d" , &p , &tot , &c );
                Cov ( p , p+tot-1 , c );
            }
            else if ( s[0]=='R' )
            {
                scanf ( "%d%d" , &p , &tot );
                Rev ( p , p+tot-1 );
            }
            else if ( s[0]=='G' )
            {
                scanf ( "%d%d" , &p , &tot );
                printf ( "%d\n" , Sum( p , p+tot-1 ) );
            }
            else
                printf ( "%d\n" , ftr[root].maxx );
        }
    }
    return 0;
}