ZOJ 2112 Dynamic Rankings

这里是题目地址

 

其实就是带修改的区间第K大。

写了一下BIT套主席树，内存飞起，似乎需要特别的优化技巧 = = 所以还是写了一下线段树套平衡树，跑了1s左右。

其实线段树套平衡树就是归并树的自然扩展而已。

归并树是把归并排序的过程建成一颗线段树，每个节点是一个数组，存的是这个节点对应区间的元素的正序：

空间复杂度O( n log n ) 。

每次查询的时候二分答案， 问题转化成询问区间中有多少个数比k小。外层查询和一般的线段树一样，只是在线段树的节点处需要再次二分得到节点区间中比k小的数的个数。这样二分答案有一个log ，线段树中询问也需要一个log ，线段树节点处二分需要一个log ，每次询问的复杂度为O( log^3 n ) 。

 

加入修改操作的时候，只需要把线段树节点的数组改为平衡树实现就好了。这是很自然的，线段树节点维护对应节点的顺序，又要支持修改，显然平衡树符合要求。

平衡树用splay实现了一下跑了1080ms ，然后用Treap实现了一下RE得浑身难受。。。实在是码力不行啊Orz

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std ;
const int N = 50000 +10 ,INF = ~1u>>1;
int M ,num[N] ;
struct node{
    node *ch[2] ,*p ;
    int size ,val ;
    bool d() ;
    void setc( node * ,bool ) ,rol() ,pushup() ;
}pool[N*19] ,*cur ,NU ,*null = &NU ;
bool node::d(){
    return p->ch[1] == this ;
}
void node::setc( node *c ,bool d ){
    ch[d] = c ,c->p = this ;
}
void node::rol(){
    node *s = p ;
    int dd = d() ;
    s->p->setc( this ,p->d() ) ;
    s->setc( ch[!dd] ,dd ) ;
    setc( s ,!dd ) ;
    s->pushup() ;
}
void node::pushup(){
    size = ch[0]->size + ch[1]->size + 1 ;
}
struct Splay{
    node *root ;
    void splay( node * ,node * ) ,insert( node * ) ;
    void change( int ,int ) ,find( int ) ,init() ;
    node *get( int ) ;
    int rank( int ) ;
}tree[N<<2] ;

node *newnode( int val ){
    cur->val = val ;
    cur->size = 1 ;
    cur->ch[0] = cur->ch[1] = cur->p = null ;
    return cur ++ ;
}
void Splay::init(){
    root = newnode(-INF) ;
}
void Splay::splay( node *x ,node *p = null ){
    while( x->p != p ){
        if( x->p->p != p )
            x->d() == x->p->d() ? x->p->rol() : x->rol() ;
        x->rol() ;
    }
    x->pushup() ;
    if( p == null ) root = x ;
}
void Splay::insert( node *x ){
    if( root == null ) root = x ,root->p = null ;
    else for( node *t = root ;; ){
        ++t->size ;
        node *&s = t->ch[ x->val > t->val ] ;
        if( s == null ){
            s = x ,s->p = t ;
            splay( x ) ;
            break ;
        }
        t = s ;
    }
}
void Splay::find( int x ){
    for( node *t = root ;; ){
        if( x == t->val ){
            splay( t ) ;
            return ;
        }
        t = t->ch[ x > t->val ] ;
    }
}
void Splay::change( int x ,int val ){
    find( x ) ;
    node *p = root ;
    node *t = get( root->ch[0]->size ) ;
    splay( t ,root ) ;
    t->setc( root->ch[1] ,1 ) ;
    t->pushup() ,root = t ,t->p = null ;
    p->val = val ,p->size = 1 ;
    p->ch[0] = p->ch[1] = null ;
    insert( p ) ;
    return ;
}
node *Splay::get( int s ){
    for( node *t = root ;; ){
        int k = t->ch[0]->size ;
        if( s == k + 1 ) return t ;
        if( s > k + 1 ) s -= k + 1 ,t = t->ch[1] ;
        else t = t->ch[0] ;
    }
}
int Splay::rank( int x ){
    int res = 0 ;
    for( node *t = root ;; ){
        node *&s = t->ch[ x > t->val ] ;
        if( t->val < x ) res += t->ch[0]->size + 1 ;
        if( s == null ){
            splay(t) ;
            return res - 1 ;
        }
        t = s ;
    }
}
void setIt( int p ,int k ,int s = M ,int x = 1 ){
    tree[x].insert( newnode(k) ) ;
    if( s == 1 ) return ;
    if( p <= s/2 ) setIt( p ,k ,s/2 ,x<<1 ) ;
    else setIt( p - s/2 ,k ,s - s/2 ,x<<1|1 ) ;
}
void change( int p ,int u ,int v ,int s = M ,int x = 1 ){
    tree[x].change( u ,v ) ;
    if( s == 1 ) return ;
    if( p <= s/2 ) change( p ,u ,v ,s/2 ,x<<1 ) ;
    else change( p-s/2 ,u ,v ,s-s/2 ,x<<1|1 ) ;
}
int Q ;
void query( int l ,int r ,int ans ,int s = M ,int x = 1 ){
    if( l <= 1 && r >= s ){
        Q += tree[x].rank(ans) ;
        return ;
    }
    if( l <= s/2 ) query( l ,r ,ans ,s/2 ,x<<1 ) ;
    if( r > s/2 ) query( l-s/2 ,r-s/2 ,ans ,s-s/2 ,x<<1|1 ) ;
}
bool judge( int l ,int r ,int ans ,int kth ){
    Q = 0 ;
    query( l ,r ,ans ) ;
    if( Q <= kth - 1 ) return 1;
    return 0 ;
}
void init(){
    cur = pool ;
}
void build( int x = 1 ,int s = M ){
    tree[x].init() ;
    if( s == 1 ) return ;
    build( x<<1 ,s/2 ) ;
    build( x<<1|1 ,s-s/2 ) ;
}
int main(){
    int n ,m ,x ,s ,t ,u ;
    int T ;
    scanf( "%d" ,&T ) ;
    while( T -- ){
        scanf("%d %d" ,&n ,&m ) ;
        M = n ;
        init() ;
        int minn = 0 ,maxn = 0 ;
        build();
        for( int i = 1 ;i <= n ;i ++ ){
            scanf( "%d" ,&x ) ;
            num[i] = x ;
            setIt( i ,x ) ;
            minn = min ( minn ,x ) ;
            maxn = max ( maxn ,x ) ;
        }
        char o[2];
        while( m -- ){
            scanf( "%s" ,&o ) ;
            if( o[0] == 'C' ){
                scanf( "%d %d" ,&s ,&t ) ;
                minn = min( minn ,t ) ;
                maxn = max( maxn ,t ) ;
                change( s ,num[s] ,t ) ;
                num[s] = t ;
                continue ;
            }
            scanf( "%d %d %d" ,&s ,&t ,&u ) ;
            int l = minn ,r = maxn ;
            while( l < r ){
                int mid = ( l + r >> 1 ) + 1 ;
                if( judge( s ,t ,mid ,u ) ) l = mid ;
                else r = mid - 1 ;
            }
            printf( "%d\n" ,l ) ;
        }
    }
}