BZOJ 3196: Tyvj 1730 二逼平衡树( 树套树 )

这道题做法应该很多吧....

我用了线段树套treap....

--------------------------------------------------------------------------------------------------------------

#include<cstdio>

#include<algorithm>

#include<cstring>

#include<cstdlib>

#include<iostream>

 

#define rep( i , n ) for( int i = 0 ; i < n ; ++i )

#define clr( x , c ) memset( x , c , sizeof( x ) )

#define Rep( i , n ) for( int i = 1 ; i <= n ; ++i )

#define M( l , r ) ( ( ( l ) + ( r ) ) >> 1 )

 

using namespace std;

 

const int maxn = 50000 + 5;

const int maxnode = 1500000;

const int inf = 1e9;

const unsigned int A = 654321 , B = 54321;

 

int seq[ maxn ] , mn , mx , n;

unsigned int P = 820;

 

// treap node

struct Node {

Node* ch[ 2 ];

int s , v;

unsigned int r;

Node() : s( 0 ) { }

inline void upd() {

s = ch[ 0 ] -> s + ch[ 1 ] -> s + 1;

}

} pool[ maxnode ] , *pt = pool , *null = pt++;

 

Node* newNode( int v = 0 ) {

pt -> v = v;

( P *= A ) += B;

pt -> r = P;

pt -> s = 1;

pt -> ch[ 0 ] = pt -> ch[ 1 ] = null;

return pt++;

}

 

struct treap {

Node* root;

treap() {

root = null;

}

void rot( Node* &t , int d ) {

Node* k = t -> ch[ d ^ 1 ];

t -> ch[ d ^ 1 ] = k -> ch[ d ];

k -> ch[ d ] = t;

t -> upd() , k -> upd();

t = k;

}

void ins( Node* &t , int v ) {

if( t == null )

t = newNode( v );

else {

int d = v > t -> v;

ins( t -> ch[ d ] , v );

if( t -> ch[ d ] -> r > t -> r )

   rot( t , d ^ 1 );

}

t -> upd();

}

void del( Node* &t , int v ) {

int d = t -> v == v ? -1 : ( t -> v < v );

if( d == -1 ) {

if( t -> ch[ 0 ] != null & t -> ch[ 1 ] != null ) {

int h = t -> ch[ 0 ] -> r > t -> ch[ 1 ] -> r;

rot( t , h ) , del( t -> ch[ h ] , v );

} else

   t = t -> ch[ 0 ] == null ? t -> ch[ 1 ] : t -> ch[ 0 ];

} else 

   del( t -> ch[ d ] , v );

if( t != null ) t -> upd();

}

int select( int k ) {

for( Node* t = root ; ; ) {

int s = t -> ch[ 0 ] -> s + 1;

if( k == s + 1 ) return t -> v;

if( k < s )

   t = t -> ch[ 0 ];

else

   k -= s + 1 , t = t -> ch[ 1 ];

}

}

int rank( int v ) {

int ans = 0;

for( Node* t = root ; t != null ; ) {

if( t -> v < v )

   ans += t -> ch[ 0 ] -> s + 1 , t = t -> ch[ 1 ];

else 

   t = t -> ch[ 0 ];

}

return ans;

}

int pred( int v ) {

int ans = -inf;

for( Node* t = root ; t != null ; ) {

if( t -> v < v )

   ans = max( ans , t -> v ) , t = t -> ch[ 1 ];

else

   t = t -> ch[ 0 ];

}

return ans;

}

int succ( int v ) {

int ans = inf;

for( Node* t = root ; t != null ; ) {

if( t -> v > v )

   ans = min( t -> v , ans ) , t = t -> ch[ 0 ];

else 

   t = t -> ch[ 1 ];

}

return ans;

}

} TREAP[ maxn << 1 ] , *pit = TREAP;

 

// segment tree node

struct node {

node *l , *r;

treap* x;

} mem[ maxn << 1 ] , *pT = mem , *Rt;

 

int L , R , v;

 

void build( node* t , int l , int r ) {

t -> x = pit++;

for( int i = l ; i <= r ; i++ )

   t -> x -> ins( t -> x -> root , seq[ i ] );

if( r > l ) {

int m = M( l , r );

build( t -> l = pT++ , l , m );

build( t -> r = pT++ , m + 1 , r );

}

}

 

void change( node* t , int l , int r ) {

if( r < L || l > L ) return;

t -> x -> del( t -> x -> root , seq[ L ] );

t -> x -> ins( t -> x -> root , v );

if( l == r ) return;

int m = M( l , r );

L <= m ? change( t -> l , l , m ) : change( t -> r , m + 1 , r );

}

 

int rank( node* t , int l , int r ) {

if( L <= l && r <= R ) 

   return t -> x -> rank( v );

int m = M( l , r );

return ( L <= m ? rank( t -> l , l , m ) : 0 ) +

      ( m < R ? rank( t -> r , m + 1 , r ) : 0 );

}

 

int pred( node* t , int l , int r ) {

if( L <= l && r <= R ) 

   return t -> x -> pred( v );

int m = M( l , r );

if( R <= m ) return pred( t -> l , l , m );

else if( L > m ) return pred( t -> r , m + 1 , r );

else return max( pred( t -> l , l , m ) , pred( t -> r , m + 1 , r ) );

}

 

int succ( node* t , int l , int r ) {

if( L <= l && r <= R ) 

   return t -> x -> succ( v );

int m = M( l , r );

if( R <= m ) return succ( t -> l , l , m );

else if( L > m ) return succ( t -> r , m + 1 , r );

else return min( succ( t -> l , l , m ) , succ( t -> r , m + 1 , r ) );

}

 

int select( int k ) {

int l = mn , r = mx , ans;

while( l <= r ) {

v = M( l , r );

int h = rank( Rt , 1 , n );

if( rank( Rt , 1 , n ) < k )

   ans = v , l = v + 1;

else

   r = v - 1;

}

return ans;

}

 

inline void read( int &x ) {

x = 0;

int sign = 1;

char c = getchar();

for( ; ! isdigit( c ) ; c = getchar() )

   if( c == '-' ) sign = -1;

for( ; isdigit( c ) ; c = getchar() )

   x = x * 10 + c - '0';

x *= sign;

}

 

int main() {

// freopen( "test.in" , "r" , stdin );

int m;

cin >> n >> m;

Rep( i , n ) {

   read( seq[ i ] );

   mn = i == 1 ? seq[ i ] : min( seq[ i ] , mn );

   mx = i == 1 ? seq[ i ] : max( seq[ i ] , mx );

}

build( Rt = pT++ , 1 , n );

int opt;

while( m-- ) {

read( opt ) , read( L );

switch( opt ) {

case 1 : read( R ); read( v ); printf( "%d\n" , rank( Rt , 1 , n ) + 1 ); break;

case 2 : read( R ); read( v ); printf( "%d\n" , select( v ) ); break;

case 3 : read( v ); change( Rt , 1 , n ); seq[ L ] = v; mn = min( v , mn ); mx = max( mx , v ); break;

case 4 : read( R ); read( v ); printf( "%d\n" , pred( Rt , 1 , n ) ); break;

case 5 : read( R ); read( v ); printf( "%d\n" , succ( Rt , 1 , n ) ); break;

}

}

return 0;

}

--------------------------------------------------------------------------------------------------------------

3196: Tyvj 1730 二逼平衡树

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 1324  Solved: 562
[Submit][Status][Discuss]

Description

您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：
1.查询k在区间内的排名
2.查询区间内排名为k的值
3.修改某一位值上的数值
4.查询k在区间内的前驱(前驱定义为小于x，且最大的数)
5.查询k在区间内的后继(后继定义为大于x，且最小的数)

Input

第一行两个数 n,m 表示长度为n的有序序列和m个操作
第二行有n个数，表示有序序列
下面有m行，opt表示操作标号
若opt=1 则为操作1，之后有三个数l,r,k 表示查询k在区间[l,r]的排名
若opt=2 则为操作2，之后有三个数l,r,k 表示查询区间[l,r]内排名为k的数
若opt=3 则为操作3，之后有两个数pos,k 表示将pos位置的数修改为k
若opt=4 则为操作4，之后有三个数l,r,k 表示查询区间[l,r]内k的前驱
若opt=5 则为操作5，之后有三个数l,r,k 表示查询区间[l,r]内k的后继

Output

对于操作1,2,4,5各输出一行，表示查询结果

Sample Input

9 6
4 2 2 1 9 4 0 1 1
2 1 4 3
3 4 10
2 1 4 3
1 2 5 9
4 3 9 5
5 2 8 5

Sample Output

2
4
3
4
9

HINT

1.n和m的数据范围：n,m<=50000

2.序列中每个数的数据范围：[0,1e8]

3.虽然原题没有，但事实上5操作的k可能为负数

Source