羅区[P3835] [テンプレート]はバランスのとれたツリーを保持することができ

永続的な非回転treap、本当に良い書き込みといい曲う〜 

コード： 

#include <cstdioを>   
する#include <cstdlib> 
の#include <アルゴリズム> 
の#define N 500007 
の#define LSON T [X] .ls 
の#define rson T [X] .RS 
の#define INF 2147483647    
の#define setIO（S）freopenは（S ".IN"、 "R"、STDIN）      
名前空間stdを使用。   
int型TOT; 
int型CUR; 
int型のPr; 
int型のNx;     
INT RT [N]。   
構造体ノード{    
    int型のval; 
    int型のサイズ。
    int型のLS、RS; 
    int型RAN;   
} T [N * 50]。              
INT newnode（）{ 
    ++ TOT。   
    T [TOT] .val = 0。
    T [TOT] .size = 1。
    T [TOT] .ran =ランド（）。
}        
    T [TOT] .ls = T [TOT = 0 .RS。   
    TOTを返します。   
    IF（！X ||！Y）{
ボイド押し上げ（INT X）{ 
    T [X] .size = T [LSON] .size + T [rson] .size + 1。   
} 
ボイドスプリット（int型のx、int型V、INT＆L、INT＆R）{ 
    もし{（X！）
        L = R = 0。
    } 
    他{   
        INT今= newnode（）。  
        T [今] = T [X]。              
        もし（T [X] .val <= V）{                    
            lは今=。  
            スプリット（rson、V、T [L] .RS、R）。
        } 
        {他
            今= R。  
            スプリット（LSON、V、L、T [R] .ls）。   
        }    
        押し上げ（今）。
    } 
} 
int型のマージ（int型のx、int型のY）{
    }       
        X + Yを返します。   
    int型になりました= newnode（）;    
    もし（T [X] .ran <T [Y] .ran）{         
        T [今] = T [X]。
        T [今] .RS =マージ（T [X] .RS、Y）。  
    } 
    他{     
        T [今] = T [Y]。  
        T [今] .ls =マージ（X、T [Y] .ls）。  
    } 
    押し上げ（今）。     
    今すぐ返します。  
}        
ボイド挿入（INTヴァル）{    
    int型のx = 0。
    = 0のint Y。             
    スプリット（RT [CUR]、ヴァル、X、Y）   
    INT _new = newnode（）。   
    T [_new] .val =ヴァル。        
    _new =マージ（X、_new）。     
    Y =マージ（_new、Y）。          
    RT [CUR] = Y。  
} 
ボイド削除（int型のval）{ 
    int型のx = 0。
    = 0のint Y。
    INT Z = 0。   
    スプリット（RT [CUR]、ヴァル、X、Z）。    
    スプリット（X、ヴァル1、X、Y）                   
    もし（Y）{        
        Y =マージ（T [Y] .ls、T [Y] .RS）。                   
    }       
    、Y =マージ（X、Y）   
    Z =マージ（Y、Z）。   
    RT [CUR] = Z; 
} 
INTランク（INTヴァル）{    
    int型のx = 0。
    = 0のint Y。    
    スプリット（RT [CUR]、ヴァル-1、X、Y）     
    INT再= T [X] .size + 1。      
    RT [CUR] =マージ（X、Y）   
    再を返します。  
} 
ボイド前（int型のx、int型のval）{                    
    （！X）であれば{ 
        リターン。  
    }      
    もし（T [X] .val <ヴァル）{
        PR = MAX（PR、T [X] .val）。                 
        プレ（rson、ヴァル）。
    }   
    他{ 
        プレ（LSON、ヴァル）。  
    } 
} 
ボイドNXT（int型のx、int型のval）{    
    （！X）であれば{ 
        リターン。
    } 
    もし（T [X] .val>ヴァル）{ 
        のNx =分（Nxを、T [X] .val）。  
        NXT（LSON、ヴァル）。
    } 
    他{ 
        NXT（rson、ヴァル）。   
    } 
} 
//查询排名为X的数   
INT民（int型のx、int型k番目）{ 
    IF（T [LSON] .size + 1つの== k番目）{ 
        戻りT [X] .val。
    }      
    場合（第k <= T [LSON] .size）{ 
        民（LSON、k番目）を返します。 
        民（rson、第k-T [LSON] .size-1）を返します。   
    }
    他{ 
    } 
} 
int型のmain（）{ 
    // setIO（ "入力"）。  
    int型I、J、M。
    scanf関数（ "％のD"、＆M）。  
    用（CUR = 1; CUR <= M; ++ CUR）{          
        int型V、OPT、X。      
        scanf関数（ "％D％D％D"、＆V、およびOPT、＆X）  
        RT [CUR] = RT [V]。          
        IF（OPT == 1）{ 
            挿入（X）。
        } 
        IF（OPT == 2）{ 
            削除（X）。
        } 
        IF（OPT == 3）{ 
            のprintf（ "％dの\ n"は、ランク（X））; 
        }   
        （OPT == 4）{場合
            のprintf（ "％dの\ n"は、テンキー（RT [CUR]、X））;   
            PR = -INF。     
            printf（ "％dの\ n"は、PR）。
        } 
        （OPT == 6）{場合
            のNx = INF。   
            NXT（RT [CUR]、X）。   
            printf（ "％dの\ n"は、Nxの）;   
        } 
    } 
    0を返します。
}