[BZOJ3224]-普通平衡树-替罪羊写法

说在前面

全机房就剩下me不会替罪羊了=A=
于是去写了一道板子题…

---

题目

BZOJ3224传送门

题面

如果你看见了 普通平衡树，BZOJ3224 这样的字眼，都还想不起来题面的话……

---

一些小细节

虽然替罪羊 原理简单 思想粗暴 证明看不懂，不过它的写法貌似还是不少。

关于删除操作

主要的差异可能还是在删除部分。第一种方法是替换删除法，删除的时候找到当前点的前驱或者后继来替换掉它。第二种方法是懒惰删除法，删除的时候给它打一个标记，而不真正的删除它，等到暴力重构的时候直接舍弃这些有标记的点即可。

关于维护信息

还有就是节点的信息，可以合并重复点，也就是在每个节点上都维护cnt，表示这个值出现了多少次，当cnt为0时相当于有了一个删除标记。而如果不合并重复点，就需要自带一个bool的删除标记。

还有还有！！因为在子树重构之后，根到子树链上的信息并没有更新，于是me为了保险起见，专门写了一个update函数取更新信息（记录下重构节点是树的第几个节点，然后从根节点往下找）。

关于查找前驱后继

为什么这个也要拿出来单独说呢？因为这玩意er花了me一上午时间才想清楚…
如果删除操作用的是替换删除，那么就可以直接使用pre和next函数去查找（也就是类似查找 左子树里最右的节点 这样）。而如果使用的是懒惰删除，就不能直接使用pre和next函数，因为有可能 左子树最右的节点 已经被删掉了….解决办法是，先得到当前数字在平衡树里的rank，然后使用查找第K大的方式去查找前驱和后继

---

下面是自带大常数的代码

真的自带大常数，这替罪羊还没有我的splay快= =
不过代码长度倒是真的很短…

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;

double antoniewa = 0.7 ;

int N , topp ;
struct Node{
    int nds , tot ;
    int siz , cnt , val ;
    Node *ch[2] , *fa ;
    void updata(){
        siz = cnt ;
        tot = 1 ; nds = ( bool )cnt ;
        if( ch[0] ) siz += ch[0]->siz , tot += ch[0]->tot , nds += ch[0]->nds ;
        if( ch[1] ) siz += ch[1]->siz , tot += ch[1]->tot , nds += ch[1]->nds ;
    }
    int cmp( const int &x ){
        if( x == val ) return -1 ;
        return x > val ? 1 : 0 ;
    }
}*root , *sta[100005] ;

bool is_Bad( Node *x ){
    if( x->ch[0] && x->ch[0]->tot > antoniewa * x->tot ) return true ;
    if( x->ch[1] && x->ch[1]->tot > antoniewa * x->tot ) return true ;
    return false ;
}

void newNode( Node *&x , const int &val ){
    x = new Node() ;
    x->val = val ;
    x->nds = x->tot = x->siz = x->cnt = 1 ;
    x->ch[0] = x->ch[1] = NULL ;
}

Node **Insert( Node *&nd , const int &x ){
    Node **rt = NULL ;
    int p = nd->cmp( x ) ;
    if( p == -1 )        nd->siz ++ , nd->cnt ++ ;
    else if( nd->ch[p] ) rt = Insert( nd->ch[p] , x ) ;
    else                 newNode( nd->ch[p] , x ) ;
    nd->updata() ;
    if( is_Bad( nd ) ) rt = &nd ;
    return rt ;
}

void dfs( Node *nd ){
    if( nd->ch[0] ) dfs( nd->ch[0] ) ;
    if( nd->cnt ) sta[ ++topp ] = nd ;
    if( nd->ch[1] ) dfs( nd->ch[1] ) ;
}

Node *divide( int lf , int rg ){
    if( lf > rg ) return NULL ;
    int mid = ( lf + rg ) >> 1 ;
    Node *nd = sta[mid] ;
    nd->ch[0] = divide( lf , mid - 1 ) ;
    nd->ch[1] = divide( mid + 1 , rg ) ;
    nd->updata() ;
    return nd ;
}

void update( Node *nd , Node *aim ){
    int p = nd->cmp( aim->val ) ;
    if( p != -1 ) update( nd->ch[p] , aim ) ;
    nd->updata() ;
}

void rebuild( Node *&nd ){
    topp = 0 ; dfs( nd ) ;
    if( nd == root ) nd = root = divide( 1 , topp ) ;
    else             nd = divide( 1 , topp ) ;
    update( root , nd ) ;
}

int Rank( Node *nd , int x ){
    if( !nd ) return 1 ;
    int rt = 0 , p = nd->cmp( x ) ;
    if( p == -1 ) return 1 + ( nd->ch[0] ? nd->ch[0]->siz : 0 ) ;
    else {
        rt = Rank( nd->ch[p] , x ) ;
        if( p == 1 ) rt += nd->siz - ( nd->ch[1] ? nd->ch[1]->siz : 0 ) ;
        return rt ;
    }
}

Node *Kth( Node *nd , int k ){
    int Lsiz = nd->cnt + ( nd->ch[0] ? nd->ch[0]->siz : 0 ) ;
    if( k > Lsiz ) return Kth( nd->ch[1] , k - Lsiz ) ;
    if( k <= Lsiz - nd->cnt ) return Kth( nd->ch[0] , k ) ;
    return nd ;
}

void Delete( Node *nd , int x ){
    int p = nd->cmp( x ) ;
    if( p == -1 ){
        if( !nd->cnt ) return ;
        nd->cnt -- , nd->siz -- ;
    } else
        Delete( nd->ch[p] , x ) ;
    nd->updata() ;
}

int main(){
    newNode( root , -(2e9+1) ) ;
    scanf( "%d" , &N ) ;
    for( int i = 1 , opt , x ; i <= N ; i ++ ){
        scanf( "%d%d" , &opt , &x ) ;
        if( opt == 1 ) {
            Node **tmp = Insert( root , x ) ;
            if( tmp != NULL ) rebuild( *tmp ) ;
        } else if( opt == 2 ) {
            Delete( root , x ) ;
            if( root->nds <= antoniewa * root->tot )
                rebuild( root ) ;
        }
        else if( opt == 3 ) printf( "%d\n" , Rank( root , x ) - 1 ) ;
        else if( opt == 4 ) printf( "%d\n" , ( Kth( root , x + 1 ) )->val ) ;
        else if( opt == 5 ) printf( "%d\n" , Kth( root , Rank( root , x )-1 ) ->val ) ;
        else if( opt == 6 ) printf( "%d\n" , Kth( root , Rank( root , x+1) ) ->val );
    }
}