高rong效chang的可持久化treap

很多人覺得可持久化treap很慢，但是事實上只是他們可持久化treap的寫法不對。他們一般是用split和merge實現所有功能，但是這樣會有許多不必要的分裂。其實我們可以用一種特殊的方式來實現插入和刪除。

插入：我們先隨機出新建節點的Rank值，隨二叉查找樹的順序找到第一個Rank比新建節點Rank小的節點，將以這個節點為根的子樹按Key值分裂成兩顆樹並作為新建節點的左子樹和右子樹。

刪除：我們用二叉查找樹的方式找到刪除節點，釋放節點空間並將節點左子樹和右子樹合並代替原樹。

由於隨機構建二叉查找樹從每個節點到葉節點期望距離是O(1)的，所以在插入刪除中期望合並的樹的深度是O（1）的。這樣一來插入刪除的log常數就只受查找速度影響（貌似比普通treap還快）

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

struct Node {
    int Key ; 
    int Rank ; 
    int Size ; 
    Node * L ; 
    Node * R ;
    Node ( int , int , int ) ;
    void maintain () ;
} ;

Node * Nil = new Node ( 0 , INT_MIN , 0 ) ;

Node :: Node ( const int Key = 0 , const int Rank = ( rand () ) , const int Size = 1 ) :
Key ( Key ) , Rank ( Rank ) , 
Size ( Size ) , L ( Nil ) , R ( Nil ) {}

void Node :: maintain () {
    Size = L -> Size + 1 + R -> Size ; 
}

Node * Merge ( Node * const L , Node * const R ) {
    if ( L == Nil ) return R ; 
    else if ( R == Nil ) return L ;
    else if ( L -> Rank > R -> Rank ) {
        L -> R = Merge ( L -> R , R ) ; 
        L -> maintain () ; 
        return L ;
    } else {
        R -> L = Merge ( L , R -> L ) ; 
        R -> maintain () ; 
        return R ;
    }
}
        
typedef pair < Node * , Node * > Npair ;

void Split1 ( Node * const O , const int K , 
Node * & L , Node * & R ) {
    if ( O == Nil ) L = R = Nil ; 
    else if ( O -> L -> Size <= K ) {
        Split1 ( O -> L , K , L , R ) ; 
        O -> L = R ;
        R = O ;
        O -> maintain () ;
    } else {
        Split1 ( O -> R , K - ( O -> L -> Size + 1 ) , L , R ) ; 
        O -> R = L ; 
        L = O ; 
        O -> maintain () ;
    }
}

void Split2 ( Node * const O , const int Key , 
Node * & L , Node * & R ) {
    if ( O == Nil ) L = R = Nil ; 
    else if ( Key <= O -> Key ) {
        Split2 ( O -> L , Key , L , R ) ; 
        O -> L = R ; 
        R = O ; 
        O -> maintain () ;
    } else {
        Split2 ( O -> R , Key , L , R ) ; 
        O -> R = L ; 
        L = O ;
        O -> maintain () ; 
    }
}

int GetRank ( const Node * O , const int Key ) {
    int ans = 0 ;
    while ( O != Nil ) {
        if ( O -> Key <= Key ) {
            O = O -> L ;
        } else {
            ans += O -> L -> Size + 1 ; 
            O = O -> R ; 
        }
    }
    return ans ;
}

void Erase ( Node * & O , const int Key ) {
    if ( O == Nil ) return ; 
    else if ( O -> Key == Key ) O = Merge ( O -> L , O -> R ) ;
    else if ( Key < O -> Key ) {
        Erase ( O -> L , Key ) ;
        O -> maintain () ; 
    } else {
        Erase ( O -> R , Key ) ;
        O -> maintain () ; 
    }
}

void Insert ( Node * & O , const int Key , const int Rank = rand () ) {
    if ( O -> Rank < Rank ) {
        Node * const np = new Node ( Key ) ;
        Split2 ( O , Key , np -> L , np -> R ) ; 
        ( O = np ) -> maintain () ;
    } else if ( Key < O -> Key ) {
        Insert ( O -> L , Key , Rank ) ; 
        O -> maintain () ; 
    } else {
        Insert ( O -> R , Key , Rank ) ; 
        O -> maintain () ; 
    }
}