bzoj 3223 裸splay

裸的splay

今儿写的splay，由于自己刚开始学，发现几个容易漏掉的地方

1：开始给所有的儿子赋值为-1

2：给max[-1]赋值为-maxlongint

3：开始father[root]:=sroot

4：在find和rotate中的push_down

5：数组的下边界为-1

6：push_down中要给标签清空

7：build中要给tree数组赋值

8：rotate操作不熟悉

由于不熟悉，发现的问题有很多，以后多加练习就好了

/**************************************************************
    Problem:
    User: BLADEVIL
    Language: Pascal
    Result: Accepted
    Time: ms
    Memory: kb
****************************************************************/
 
//By BLADEVIL
const
    sroot                           =-;
     
var
    n, m                            :longint;
    x, y                            :longint;
    a                               :array[-..] of longint;
    tree, size, father              :array[-..] of longint;
    son                             :array[-..,..] of longint;
    flag                            :array[-..] of boolean;
    root                            :longint;
    i                               :longint;
     
procedure swap(var a,b:longint);
var
    c                               :longint;
begin
    c:=a; a:=b; b:=c;
end;
     
procedure update(x:longint);
begin
    size[x]:=size[son[x,]]+size[son[x,]]+;
end;
     
procedure renew_reverse(x:longint);
begin
    swap(son[x,],son[x,]);
    flag[x]:=not flag[x];
end;
 
procedure push_down(x:longint);
var
    l, r                            :longint;
begin
    l:=son[x,]; r:=son[x,];
    if flag[x] then
    begin
        if l<>- then renew_reverse(l);
        if r<>- then renew_reverse(r);
        flag[x]:=false;
    end;
end;
     
function build(l,r:longint):longint;
var
    mid                             :longint;
begin
    mid:=(l+r) div ;
    build:=mid;
    tree[mid]:=a[mid];
    if mid->=l then
    begin
        son[mid,]:=build(l,mid-);
        father[son[mid,]]:=mid;
    end;
    if mid+<=r then
    begin
        son[mid,]:=build(mid+,r);
        father[son[mid,]]:=mid;
    end;
    update(mid);
end;
 
function find(x:longint):longint;
var
    t                               :longint;
begin
    t:=root;
    while true do
    begin
        push_down(t);
        if size[son[t,]]+=x then exit(t);
        if size[son[t,]]+>x then t:=son[t,] else
        begin
            dec(x,size[son[t,]]+);
            t:=son[t,];
        end;
    end;
end;
 
procedure rotate(x,y:longint);
var
    f                               :longint;
begin
    push_down(x);
    f:=father[x];
    son[f,y]:=son[x,y xor ];
    father[son[x,y xor ]]:=f;
    if f=root then root:=x else
        if f=son[father[f],] then
            son[father[f],]:=x else
            son[father[f],]:=x;
    father[x]:=father[f];
    father[f]:=x;
    son[x,y xor ]:=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],])) else
        begin
            if x=son[father[x],] then u:= else u:=-;
            if father[x]=son[father[father[x]],] then v:= else v:=-;
            if u*v= then
            begin
                rotate(father[x],ord(x=son[father[x],]));
                rotate(x,ord(x=son[father[x],]));
            end else
            begin
                rotate(x,ord(x=son[father[x],]));
                rotate(x,ord(x=son[father[x],]));
            end;
        end;
    end;
    update(x);
end;
     
procedure reverse(l,r:longint);
var
    p                               :longint;
begin
    p:=find(l); splay(p,sroot);
    p:=find(r+); splay(p,root);
    p:=son[son[root,],];
    renew_reverse(p);
end;
     
begin
    fillchar(son,sizeof(son),);
    read(n,m);
    for i:= to n do a[i]:=i;
    inc(n);
    root:=build(,n);
    father[root]:=sroot;
    for i:= to m do
    begin
        read(x,y);
        reverse(x,y);
    end;
    for i:= to n do write(find(i),' '); writeln;
end.