bzoj 1251 裸splay

裸的splay，只需要注意 max[-1]:=-maxlongint 就行了，否则在update的时候子节点的

max值会在max[-1]里选

/**************************************************************
    Problem: 1251
    User: BLADEVIL
    Language: Pascal
    Result: Accepted
    Time:16008 ms
    Memory:3448 kb
****************************************************************/
 
//By BLADEVIL
const
    sroot                   =-1;
var
    n, m                    :longint;
    i                       :longint;
    a, father               :array[-1..100010] of longint;
    k, l, r, v              :longint;
    root                    :longint;
    max, size, tree         :array[-1..100010] of longint;
    val                     :array[-1..100010] of longint;
    flag                    :array[-1..100010] of boolean;
    son                     :array[-1..100010,0..1] of longint;
     
procedure swap(var a,b:longint);
var
    c                       :longint;
begin
    c:=a; a:=b; b:=c;
end;
     
function get_max(a,b:longint):longint;
begin
    if a>b then exit(a) else exit(b);
end;
 
procedure renew_add(x,v:longint);
begin
    inc(tree[x],v); inc(val[x],v); inc(max[x],v);
end;
 
procedure renew_reverse(x:longint);
begin
    swap(son[x,1],son[x,0]);
    flag[x]:=not flag[x];
end;
     
procedure update(x:longint);
begin
    //if x=sroot then exit;
    max[x]:=get_max(tree[x],get_max(max[son[x,1]],max[son[x,0]]));
    size[x]:=size[son[x,1]]+size[son[x,0]]+1;
end;
     
function build(l,r:longint):longint;
var
    mid                     :longint;
begin
    mid:=(r+l) div 2;
    build:=mid;
    tree[mid]:=a[mid];
    if l+1<=mid then
    begin
        son[mid,0]:=build(l,mid-1);
        father[son[mid,0]]:=mid;
    end;
    if mid<=r-1 then
    begin
        son[mid,1]:=build(mid+1,r);
        father[son[mid,1]]:=mid;
    end;
    update(mid);
end;
 
procedure push_down(x:longint);
var
    l, r                    :longint;
begin
    l:=son[x,0]; r:=son[x,1];
    if flag[x] then
    begin
        if l<>-1 then renew_reverse(l);
        if r<>-1 then renew_reverse(r);
        flag[x]:=false;
    end;
    if val[x]<>0 then
    begin
        if l<>-1 then renew_add(l,val[x]);
        if r<>-1 then renew_add(r,val[x]);
        val[x]:=0;
    end;
end;
     
function find(x:longint):longint;
var
    t                       :longint;
begin
    t:=root;
    while true do
    begin
        push_down(t);
        if size[son[t,0]]+1=x then exit(t);
        if size[son[t,0]]+1>x then t:=son[t,0] else
        begin
            dec(x,size[son[t,0]]+1);
            t:=son[t,1];
        end;
    end;
end;
 
procedure rotate(x,y:longint);
var
    f                       :longint;
begin
    push_down(x);
    f:=father[x];
    father[son[x,y xor 1]]:=f;
    son[f,y]:=son[x,y xor 1];
    if f=root then root:=x else
        if f=son[father[f],0] then
            son[father[f],0]:=x else
            son[father[f],1]:=x;
    father[x]:=father[f];
    father[f]:=x;
    son[x,y xor 1]:=f;
    update(f);
    update(x);
end;
 
procedure splay(x,y:longint);
var
    u, v                    :longint;
begin
    while father[x]<>y do
    begin
        if father[father[x]]=y then
            rotate(x,ord(x=son[father[x],1])) else
        begin
            if son[father[x],0]=x then u:=1 else u:=-1;
            if son[father[father[x]],0]=father[x] then v:=1 else v:=-1;
            if u*v=1 then
            begin
                rotate(father[x],ord(x=son[father[x],1]));
                rotate(x,ord(x=son[father[x],1]));
            end else
            begin
                rotate(x,ord(x=son[father[x],1]));
                rotate(x,ord(x=son[father[x],1]));
            end;
        end;
    end;
    update(x);
end;
     
procedure add(l,r,v:longint);
var
    p                       :longint;
begin
    p:=find(l);splay(p,sroot);
    p:=find(r+2);splay(p,root);
    p:=son[son[root,1],0];
    renew_add(p,v);
end;
 
procedure reverse(l,r:longint);
var
    p                       :longint;
begin
    p:=find(l);splay(p,sroot);
    p:=find(r+2);splay(p,root);
    p:=son[son[root,1],0];
    renew_reverse(p);
end;
 
function ask_max(l,r:longint):longint;
var
    p                       :longint;
begin
    p:=find(l); splay(p,sroot);
    p:=find(r+2); splay(p,root);
    p:=son[son[root,1],0];
    ask_max:=max[p];
end;
     
begin
    fillchar(son,sizeof(son),255);
    read(n,m);
    max[-1]:=-maxlongint;
    for i:=1 to n do a[i]:=0;
    inc(n);
    root:=build(0,n);
    father[root]:=sroot;
    for i:=1 to m do
    begin
        read(k);
        if k=1 then
        begin
            read(l,r,v);
            add(l,r,v);
        end else
        begin
            read(l,r);
            if k=2 then    
                reverse(l,r) else
                writeln(ask_max(l,r));
        end;
    end;
end.