[BZOJ3110][Zjoi2013]-K大数查询-树套树

说在前面

第一次写树套树，从上午9点写到下午三点半，先是自己没想清楚，yy了个时间复杂度起飞的套法。然后换了一种套法继续写，然而又被人造数据强行卡int= =#

题目

BZOJ3110传送门

洛谷P3332传送门

题目描述

有N个位置，M个操作。操作有两种，每次操作如果是1 a b c的形式表示在第a个位置到第b个位置，每个位置加入一个数c

如果是2 a b c形式，表示询问从第a个位置到第b个位置，第C大的数是多少。

输入输出格式

输入格式：

第一行N，M接下来M行，每行形如1 a b c或2 a b c

输出格式：

输出每个询问的结果

输入输出样例

输入样例#1：

2 5

1 1 2 1

1 1 2 2

2 1 1 2

2 1 1 1

2 1 2 3

输出样例#1：

1

2

1

解法

—->me的整体二分做法传送门

树套树

比较容易想清楚的是，一棵线段树只能维护一维的信息

如果一棵线段树以值域来建树，那么这棵树就无法维护下标（位置），同理其他

但是这个题需要区间第K大，位置信息和值域信息都需要保存，因此使用树套树。主树维护值域，小树维护下标（位置），Query和Modify都需要写两个。注意这棵树套树需要动态开点。然后呢，这里是不能主树维护下标而小树维护值域的，如果这样写的话，主树没有办法用永久化标记，要写Pushdown的话复杂度也无法保证（会一层层的往下push）

然后有个比较坑的地方，因为N和M都是50000的规模，那么me可以每次都使区间[1,50000]加上同一个数c，数字c出现的次数就会超过int，这里就需要使用unsigned int或者long long。

另外，针对这个数据，直接用int读入，在查询的时候遇见nd为NULL直接return N也可以过。这样会比使用long long快两秒左右

下面是自带大常数的代码

/**************************************************************
Problem: 3110
User: Izumihanako
Language: C++
Result: Accepted
Time:9160 ms
Memory:286396 kb
****************************************************************/
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;

int N , M , upN , downN , a , b ;
long long c ;

struct downNode{//小树代表下标
int tag ;
long long cnt ;
downNode *ls , *rs ;
void init( ){
cnt = tag = 0 ;
}
}dw[50005*17*16] , *tdw = dw ;

struct upNode{//大树代表值域
upNode *ls , *rs ;
downNode *down ;
void init(){
down = ++tdw ;
down->init() ;
}
}uw[100005*17] , *tuw = uw , *root ;

void up_Newnode( upNode *&nd ){
nd = ++tuw ;
nd->init() ;
}

void down_Newnode( downNode *&nd ){
nd = ++tdw ;
nd->init() ;
}

void down_Update( downNode *nd , int lf , int rg ){
if( !nd->ls ) nd->ls = ++tdw , tdw->init() ;
if( !nd->rs ) nd->rs = ++tdw , tdw->init() ;
nd->cnt = nd->ls->cnt + nd->rs->cnt + 1LL * nd->tag * ( rg - lf + 1 ) ;
}

void downAdd( downNode *&nd , int lf , int rg , int L , int R ){
if( !nd ) down_Newnode( nd ) ;
if( L <= lf && rg <= R ){
nd->cnt += ( rg - lf + 1 ) ;
nd->tag ++ ; return ;
}
int mid = ( lf + rg ) >> 1 ;
if( L <= mid ) downAdd( nd->ls , lf ,  mid , L , R ) ;
if( R >  mid ) downAdd( nd->rs , mid+1, rg , L , R ) ;
down_Update( nd , lf , rg ) ;
}

long long downQuery( downNode *nd , int lf , int rg , int L , int R ){
if( !nd ) return 0 ;
if( L <= lf && rg <= R ) return nd->cnt ;
int mid = ( lf + rg ) >> 1 ;
long long rt = 1LL * ( min( R , rg ) - max( L , lf ) + 1 ) * nd->tag ;
if( L <= mid ) rt += downQuery( nd->ls , lf ,  mid , L , R ) ;
if( R >  mid ) rt += downQuery( nd->rs , mid+1, rg , L , R ) ;
return rt ;
}

void upAdd( upNode *&nd , int lf , int rg , int pos ){
if( !nd ) up_Newnode( nd ) ;
downAdd( nd->down , 1 , downN , a , b ) ;
if( lf == rg ) return ;
int mid = ( lf + rg ) >> 1 ;
if( pos <= mid ) upAdd( nd->ls , lf ,  mid , pos ) ;
if( pos >  mid ) upAdd( nd->rs , mid+1, rg , pos ) ;
}

int upQuery( upNode *nd , int lf , int rg , long long K ){
if( lf == rg ) return lf - N ;
//if( !nd ) return N ;
int mid = ( lf + rg ) >> 1 ;
long long Rcnt = ( nd->rs ? downQuery( nd->rs->down , 1 , downN , a , b ) : 0 ) ;
if( K <= Rcnt ) return upQuery( nd->rs , mid+1, rg , K ) ;
else            return upQuery( nd->ls , lf ,  mid , K - Rcnt ) ;
}

void solve(){
for( int i = 1 , o ; i <= M ; i ++ ){
scanf( "%d%d%d%lld" , &o , &a , &b , &c ) ;
switch(o){
case 1 :{
upAdd( root , 1 , upN , c + N ) ;
break;
}
case 2 :
printf( "%d\n" , upQuery( root , 1 , upN , c ) ) ;
}
}
}

int main(){
scanf( "%d%d" , &N , &M ) ;
upN = N + N ; downN = N ;
solve() ;
}