bzoj 3196二逼平衡树 线段树套平衡树

比较裸的树套树，对于区间K值bz上有一道裸题，详见题解http://www.cnblogs.com/BLADEVIL/p/3455336.html（其实题解也不是很详细）

//By BLADEVIL
type
    rec                            =record
        left, right, root        :longint;
    end;

var
    n, m                        :longint;
    a                            :array[0..100100] of longint;
    t                            :array[0..300300] of rec;
    b_left, b_right, b_key        :array[0..1000010] of longint;
    b_size                        :array[0..1000010] of longint;
    tot                            :longint;
    
function min(a,b:longint):longint;
begin
    if a>b then min:=b else min:=a;
end;

function max(a,b:longint):longint;
begin
    if a>b then max:=a else max:=b;
end;
    
procedure left_rotate(var t:longint);
var
    k                            :longint;
begin
    k:=b_right[t];
    b_right[t]:=b_left[k];
    b_left[k]:=t;
    b_size[k]:=b_size[t];
    b_size[t]:=b_size[b_left[t]]+b_size[b_right[t]]+1;
    t:=k;
end;

procedure right_rotate(var t:longint);
var
    k                            :longint;
begin
    k:=b_left[t];
    b_left[t]:=b_right[k];
    b_right[k]:=t;
    b_size[k]:=b_size[t];
    b_size[t]:=b_size[b_left[t]]+b_size[b_right[t]]+1;
    t:=k;
end;
    
procedure maintain(var t:longint;flag:boolean);
begin
    if not flag then 
    begin
        if b_size[b_left[b_left[t]]]>b_size[b_right[t]] then 
            right_rotate(t) else 
        if b_size[b_right[b_left[t]]]>b_size[b_right[t]] then 
        begin
            left_rotate(b_left[t]);
            right_rotate(t);
        end else exit;
    end else 
    begin
        if b_size[b_right[b_right[t]]]>b_size[b_left[t]] then 
            left_rotate(t) else 
        if b_size[b_left[b_right[t]]]>b_size[b_left[t]] then 
        begin
            right_rotate(b_right[t]);
            left_rotate(t);
        end else exit;
    end;
    maintain(b_left[t],false);
    maintain(b_right[t],true);
    maintain(t,true);
    maintain(t,false);
end;
    
procedure insert(var t:longint;v:longint);
begin
    if t=0 then 
    begin
        inc(tot);
        t:=tot;
        b_left[t]:=0;
        b_right[t]:=0;
        b_size[t]:=1;
        b_key[t]:=v;
    end else 
    begin
        inc(b_size[t]);
        if v>=b_key[t] then insert(b_right[t],v) else insert(b_left[t],v);
        maintain(t,v>=b_key[t]);
    end;
end;

function delete(var t:longint; v:longint):longint;
begin
    dec(b_size[t]);
    if (b_key[t]=v) or (b_key[t]<v) and (b_right[t]=0) or (b_key[t]>v) and (b_left[t]=0) then 
    begin
        delete:=b_key[t];
        if (b_left[t]=0) or (b_right[t]=0) then 
            t:=b_left[t]+b_right[t] else 
            b_key[t]:=delete(b_left[t],v+1);
    end else 
        if v>b_key[t] then delete:=delete(b_right[t],v) else delete:=delete(b_left[t],v);
end;

procedure build(x,l,r:longint);
var
    mid                            :longint;
    i                            :longint;
begin
    t[x].left:=l; t[x].right:=r; t[x].root:=0;
    for i:=l to r do insert(t[x].root,a[i]);
    if l=r then exit;
    with t[x] do mid:=(left+right) div 2;
    build(x*2,l,mid); build(x*2+1,mid+1,r);
end;

function b_rank(var t:longint;v:longint):longint;
begin
    if t=0 then exit(0);
    if v<=b_key[t] then 
        b_rank:=b_rank(b_left[t],v) else 
        b_rank:=b_rank(b_right[t],v)+b_size[b_left[t]]+1;
end;
    
procedure init;
var
    i                            :longint;
    
begin
    read(n,m);
    for i:=1 to n do read(a[i]);
    build(1,1,n);
end;

function rank(x,l,r,y:longint):longint;
var
    mid                            :longint;
begin
    if (t[x].left=l) and (t[x].right=r) then 
    begin
        rank:=b_rank(t[x].root,y);
        exit;
    end;
    with t[x] do mid:=(left+right) div 2;
    if mid<l then rank:=rank(x*2+1,l,r,y) else 
    if mid>=r then rank:=rank(x*2,l,r,y) else 
    rank:=rank(x*2,l,mid,y)+rank(x*2+1,mid+1,r,y);
end;

procedure askrank(l,r,x:longint);    
begin
    writeln(rank(1,l,r,x)+1);
end;

procedure change(x,y,z,c:longint);
var
    mid                            :longint;
begin
    mid:=delete(t[x].root,c);
    insert(t[x].root,z);
    if t[x].left=t[x].right then exit;
    with t[x] do mid:=(left+right) div 2;
    if y>mid then change(x*2+1,y,z,c) else 
        change(x*2,y,z,c);
end;

function b_pred(var t:longint;v:longint):longint;
begin
    if t=0 then exit(-1);
    if v<=b_key[t] then b_pred:=b_pred(b_left[t],v) else 
    begin
        b_pred:=b_pred(b_right[t],v);
        if b_pred=-1 then b_pred:=b_key[t];
    end;
end;

function pred(x,l,r,y:longint):longint;
var
    mid                            :longint;
begin
    if (t[x].left=l) and (t[x].right=r) then
    begin
        pred:=b_pred(t[x].root,y);
        exit;
    end;
    with t[x] do mid:=(left+right) div 2;
    if mid<l then pred:=pred(x*2+1,l,r,y) else 
    if mid>=r then pred:=pred(x*2,l,r,y) else 
    pred:=max(pred(x*2,l,mid,y),pred(x*2+1,mid+1,r,y));
end;

procedure askpred(l,r,x:longint);
begin
    writeln(pred(1,l,r,x));
end;

function b_succ(var t:longint;v:longint):longint;
begin
    if t=0 then exit(maxlongint);
    if v>=b_key[t] then b_succ:=b_succ(b_right[t],v) else 
    begin
        b_succ:=b_succ(b_left[t],v);
        if b_succ=maxlongint then b_succ:=b_key[t];
    end;
end;

function succ(x,l,r,y:longint):longint;
var
    mid                            :longint;
begin
    if (t[x].left=l) and (t[x].right=r) then
    begin
        succ:=b_succ(t[x].root,y);
        exit;
    end;
    with t[x] do mid:=(left+right) div 2;
    if mid<l then succ:=succ(x*2+1,l,r,y) else 
    if mid>=r then succ:=succ(x*2,l,r,y) else
        succ:=min(succ(x*2,l,mid,y),succ(x*2+1,mid+1,r,y));
end;

procedure askselect(a,b,x:longint);
var
    mid                            :longint;
    ans                            :longint;
    l, r                        :longint;
    xx                            :longint;
begin
    l:=0; r:=1000000000;
    while l<=r do 
    begin
        mid:=(l+r) div 2;
        xx:=rank(1,a,b,mid)+1;
        if xx<=x then 
        begin
            ans:=mid;
            l:=mid+1;
        end else r:=mid-1;
    end;
    if rank(1,a,b,ans)=x then ans:=succ(1,l,r,ans-1) else ans:=ans;
    writeln(ans);
end;

procedure asksucc(l,r,x:longint);
begin
    writeln(succ(1,l,r,x));
end;

procedure main;
var
    i                            :longint;
    k, l, r, x                    :longint;
    
begin
    for i:=1 to m do 
    begin
        read(k);
        if k=1 then 
        begin
            read(l,r,x);
            askrank(l,r,x);
        end else 
        if k=2 then 
        begin
            read(l,r,x);
            askselect(l,r,x);
        end else
        if k=3 then 
        begin
            read(l,x);
            change(1,l,x,a[l]);
            a[l]:=x;
        end else 
        if k=4 then
        begin
            read(l,r,x);
            askpred(l,r,x);
        end else 
        if k=5 then 
        begin
            read(l,r,x);
            asksucc(l,r,x);
        end;
    end;
end;

begin
    init;
    main;
end.