[PKU 3580 3468][Noi 2005 Sequance]伸展树Splay & 平衡树SBT(下)

{

承上一部分

}

我们在上半部分说到伸展树不是用来作为平衡树使用的

而应当将它的Splay操作发扬光大

我们先来讨论一下Splay操作

splay操作的具体实现可以从杨思雨的论文里了解

不过我找到的论文只有pdf和ppt(汗)

于是就去看splay的算法

看的云里雾里 只知道splay是一个提根操作

还要分六种情况讨论(大汗)

我觉得直接单旋提根也不会差多少

编程复杂度还低

于是 引用杨思雨论文里的一句话

……不能只一味的追求算法有很高的时间效率，而需要在时间复杂度、空间复杂度、编程复杂度三者之间找到一个“平衡点”……

于是我就选择了只用单旋来实现splay

这段程序是我自己设计实现的 但是总觉得和双旋的代码有某种相似(巨汗)

(其实应当算作是殊途同归吧)

贴个代码先

 

procedure zig(var x:longint);
 var    y:longint;
 begin
y:=l[x]; l[x]:=r[y]; r[y]:=x;
f[y]:=f[x]; f[x]:=y;
 if l[x]<>0 then f[l[x]]:=x;
x:=y;
 end;
 procedure zag(var x:longint);
 var    y:longint;
 begin
y:=r[x]; r[x]:=l[y]; l[y]:=x;
f[y]:=f[x]; f[x]:=y;
 if r[x]<>0 then f[r[x]]:=x;
x:=y;
 end;
 procedure splay(var x,S:longint);
 begin
 while f[x]<>f[S] do
    if l[f[x]]=x
        then begin
        if f[x]=S
            then zig(S)
            else if l[f[f[x]]]=f[x]
                then zig(l[f[f[x]]])
                else zig(r[f[f[x]]]);
        end
        else begin
        if f[x]=S
            then zag(S)
            else if l[f[f[x]]]=f[x]
                then zag(l[f[f[x]]])
                else zag(r[f[f[x]]]);
        end;
 end;

可以看到

splay需要两个子过程 左旋和右旋

　　splay还是一个两个参数的函数 其中x是所提的节点 S是所在子树的根节点 也就是x最后所在的位置

　　x是值参 S是变参 (这里给x也是变参 不过没什么区别的) 

为了自底向上splay 我们还需记录父亲节点即f 数组

旋转和SBT类似 就多了2句更新父亲的话

具体分析一下splay函数

　　19行一个while循环 将x旋转直到x为子树的根

　　20行判断x是其父亲的左儿子还是右儿子 根据左右情况 决定左旋还是右旋

　　左右是对称的 我们具体讨论是父亲的左儿子的情况

　　　　21行判断是父亲否为根 如果为根直接旋转根

　　　　否则继续讨论父亲是否是祖父的左儿子 是则旋转祖父的左儿子 否则旋转祖父的右儿子

　　这里兜了一个圈子 祖父的儿子不就是父亲么?

　　其实不然 在程序中f[x]和l[f[f[x]]]或r[f[f[x]]]虽然是同一个值但不是同一个变量

　　我们看到旋转函数的参数是一个变参 于是考虑这个参数是哪一个变得很重要 否则就会出错

　　我们回想SBT的旋转 在SBT中 我们旋转的参数是l[x]或r[x]

　　那么在这里同理我们也应当用儿子指针当参数而不是父亲指针

　　我们使用变参的初衷是为了免去修改节点的同时修改节点父亲的儿子指针的过程

　　于是splay的旋转也应当传递节点父亲的儿子指针 并在最后使用x:=y来修改

这样一个splay函数就完成了

经过测试 这样和双旋的时间差不了多少

其实很方便的

测试时我用的是记录size域的splay(单旋双旋)和SBT

对于1000000次操作的随机数据SBT是5s+ splay差不多都是7s+

可见splay常数确实大 作为自平衡的排序二叉树使用确实不如SBT

也可以发现单旋还是很实用的

贴一下带size域的splay(支持的各项操作和SBT一致)

const    max=300000;
 var    f,l,r,s,n:array[0..max]of longint;
    stack:array[1..max]of longint;
    top,tt,root,i,m,order,k:longint;
 procedure zig(var x:longint);
 var    y:longint;
 begin
y:=l[x]; l[x]:=r[y]; r[y]:=x;
f[y]:=f[x]; f[x]:=y;
 if l[x]<>0 then f[l[x]]:=x;
s[y]:=s[x]; s[x]:=s[l[x]]+s[r[x]]+1;
x:=y;
 end;
 procedure zag(var x:longint);
 var    y:longint;
 begin
y:=r[x]; r[x]:=l[y]; l[y]:=x;
f[y]:=f[x]; f[x]:=y;
 if r[x]<>0 then f[r[x]]:=x;
s[y]:=s[x]; s[x]:=s[l[x]]+s[r[x]]+1;
x:=y;
 end;
 procedure splay(x:longint; var S:longint);
 begin
 while f[x]<>f[S] do
    if l[f[x]]=x
        then begin
        if f[x]=S
            then zig(S)
            else if l[f[f[x]]]=f[x]
                then zig(l[f[f[x]]])
                else zig(r[f[f[x]]]);
        end
        else begin
        if f[x]=S
            then zag(S)
            else if l[f[f[x]]]=f[x]
                then zag(l[f[f[x]]])
                else zag(r[f[f[x]]]);
        end;
 end;
 procedure newnode(var x:longint);
 begin
 if top>0
    then begin x:=stack[top]; dec(top); end
    else begin inc(tt); x:=tt; end;
f[x]:=0; l[x]:=0; r[x]:=0;
 end;
 procedure clrnode(var x:longint);
 begin
inc(top); stack[top]:=x;
 end;
 procedure insert(var x:longint; v:longint);
 var    i,j:longint;
 begin
 if x=0
    then begin
    newnode(x);
    n[x]:=v; s[x]:=1;
    exit; end;
j:=x;
 while j<>0 do
    begin
    i:=j;
    inc(s[i]);
    if v<=n[i] then j:=l[i] else j:=r[i];
    end;
newnode(j);
 if v<=n[i] then l[i]:=j else r[i]:=j;
n[j]:=v; s[j]:=1; f[j]:=i;
splay(j,x);
 end;
 procedure join(var x,y:longint);
 var    i,j:longint;
 begin
 if (x=0)or(y=0)
        then begin
        x:=x+y;
        exit; end;
i:=x; j:=y;
 while r[i]<>0 do i:=r[i];
 while l[j]<>0 do j:=l[j];
splay(i,x); splay(j,y);
r[i]:=j; f[j]:=i;
s[i]:=s[i]+s[j];
x:=i;
 end;
 procedure delete(var x:longint; v:longint);
 var    i,j:longint;
 begin
i:=x;
 while (i<>0)and(n[i]<>v) do
    if v<n[i] then i:=l[i] else i:=r[i];
 if i=0 then exit;
splay(i,x);
join(l[i],r[i]);
j:=x; x:=l[i]; f[x]:=f[j];
clrnode(j);
 end;
 function find(x,v:longint):boolean;
 begin
 if x=0 then exit(false);
 if v=n[x] then exit(true);
 if v<n[x]
    then find:=find(l[x],v)
    else find:=find(r[x],v);
 end;
 function rank(x,v:longint):longint;
 begin
 if x=0 then exit(1);
 if v<=n[x]
    then rank:=rank(l[x],v)
    else rank:=rank(r[x],v)+1+s[l[x]];
 end;
 function select(x,k:longint):longint;
 begin
 if s[l[x]]+1=k then exit(n[x]);
 if k<=s[l[x]]
    then select:=select(l[x],k)
    else select:=select(r[x],k-s[l[x]]-1);
 end;
 function pred(x,v:longint):longint;
 begin
 if x=0 then exit(v);
 if v<=n[x]
    then pred:=pred(l[x],v)
    else begin
    pred:=pred(r[x],v);
    if pred=v then pred:=n[x];
    end;
 end;
 function succ(x,v:longint):longint;
 begin
 if x=0 then exit(v);
 if v>=n[x]
    then succ:=succ(r[x],v)
    else begin
    succ:=succ(l[x],v);
    if succ=v then succ:=n[x];
    end;
 end;
 begin
assign(input,'bst.in'); reset(input);
assign(output,'bst.out'); rewrite(output);
readln(m);
root:=0; tt:=0; s[0]:=0; top:=0;
 for i:=1 to m do
    begin
    readln(order,k);
    case order of
        1:insert(root,k);
        2:delete(root,k);
        3:writeln(find(root,k));
        4:writeln(rank(root,k));
        5:if k<=s[root] then writeln(select(root,k))
            else writeln(-1);
        6:writeln(pred(root,k));
        7:writeln(succ(root,k));
        end;
    end;
close(input); close(output);
 end.
 

//2010-11-9 更新 优化过的代码

//Splay Tree To Deal with Repeated Node
//21~11 2010-11-9
const    maxn=500000;
var    stack,l,r,n,s,t,f:array[0..maxn]of longint;
    tt,top,root,i,q,c,x:longint;

//Splay(x,S);
procedure zig(var x:longint);
var    y:longint;
begin
y:=l[x]; l[x]:=r[y]; r[y]:=x;
f[y]:=f[x]; f[x]:=y;
if l[x]<>0 then f[l[x]]:=x;
s[y]:=s[x]; s[x]:=s[l[x]]+s[r[x]]+t[x];
x:=y;
end;
procedure zag(var x:longint);
var    y:longint;
begin
y:=r[x]; r[x]:=l[y]; l[y]:=x;
f[y]:=f[x]; f[x]:=y;
if r[x]<>0 then f[r[x]]:=x;
s[y]:=s[x]; s[x]:=s[l[x]]+s[r[x]]+t[x];
x:=y;
end;
procedure splay(x:longint; var S:longint);
begin
while f[x]<>f[S] do
    if l[f[x]]=x
        then if f[x]=S then zig(S)
            else if l[f[f[x]]]=f[x]
                then zig(l[f[f[x]]])
                else zig(r[f[f[x]]])
        else if f[x]=S then zag(S)
            else if l[f[f[x]]]=f[x]
                then zag(l[f[f[x]]])
                else zag(r[f[f[x]]]);
end;

//New and Dispose a Node
procedure newnode(var x:longint);
begin
if top=0
    then begin
    inc(tt);
    x:=tt;
    end
    else begin
    x:=stack[top];
    dec(top);
    end;
end;
procedure disnode(x:longint);
begin
inc(top);
stack[top]:=x;
end;

//FindIt FindMax FindMin
function find(v:longint):boolean;
var    i:longint;
begin
i:=root;
while i<>0 do
    begin
    if n[i]=v
        then begin
        splay(i,root);
        exit(true);
        end;
    if v<n[i] then i:=l[i]
        else i:=r[i];
    end;
find:=false;
end;
function max(var x:longint):longint;
var    i:longint;
begin
i:=x;
while r[i]<>0 do
    i:=r[i];
max:=n[i];
splay(i,x);
end;
function min(var x:longint):longint;
var    i:longint;
begin
i:=x;
while l[i]<>0 do
    i:=l[i];
min:=n[i];
splay(i,x);
end;

//Insert Delete Union
procedure insert(v:longint);
var    i,j,x:longint;
begin
if find(v)
    then begin
    inc(t[root]);
    inc(s[root]);
    end
    else begin
    newnode(x);
    f[x]:=0; l[x]:=0; r[x]:=0;
    n[x]:=v; s[x]:=1; t[x]:=1;
    if root=0
        then root:=x
        else begin
        i:=root; j:=root;
        while i<>0 do
            begin
            inc(s[i]); j:=i;
            if v<n[i] then i:=l[i]
                else i:=r[i];
            end;
        if v<n[j] then l[j]:=x
            else r[j]:=x;
        f[x]:=j;
        splay(x,root);
        end;
    end;
end;
function union(var x,y:longint):longint;
begin
if x=0
    then begin
    f[y]:=0;
    exit(y);
    end;
max(x);
f[x]:=0; r[x]:=y; f[y]:=x;
s[x]:=s[l[x]]+s[r[x]]+t[x];
union:=x;
end;
procedure delete(v:longint);
var    temp:longint;
begin
if find(v)
    then if t[root]>1
        then begin
        dec(t[root]);
        dec(s[root]);
        end
        else begin
        temp:=union(l[root],r[root]);
        disnode(root);
        root:=temp;
        end;
end;

//Rank Select
function rank(v:longint):longint;
var    i,j:longint;
begin
i:=root; j:=0;
while i<>0 do
    if v<=n[i]
        then i:=l[i]
        else begin
        j:=j+s[l[i]]+t[i];
        i:=r[i];
        end;
rank:=j+1;
end;
function select(k:longint):longint;
var    i:longint;
begin
if k>s[root]
    then exit(-1);
i:=root;
while true do
    begin
    if (s[l[i]]<k)and(k<=s[l[i]]+t[i])
        then exit(n[i]);
    if k<=s[l[i]]
        then i:=l[i]
        else begin
        k:=k-s[l[i]]-t[i];
        i:=r[i];
        end;
    end;
end;

//Pred Succ
function pred(v:longint):longint;
var    flag:boolean;
begin
flag:=not find(v);
if flag then insert(v);
if l[root]=0
    then pred:=v
    else pred:=max(l[root]);
if flag then delete(v);
end;
function succ(v:longint):longint;
var    flag:boolean;
begin
flag:=not find(v);
if flag then insert(v);
if r[root]=0
    then succ:=v
    else succ:=min(r[root]);
if flag then delete(v);
end;

//Main
begin
assign(input,'bst.in'); reset(input);
assign(output,'bst1.out'); rewrite(output);
readln(q);
s[0]:=0; t[0]:=0;
tt:=0; root:=0; top:=0;
for i:=1 to q do
    begin
    readln(c,x);
    case c of
        1:insert(x);
        2:delete(x);
        3:writeln(find(x));
        4:writeln(rank(x));
        5:writeln(select(x));
        6:writeln(pred(x));
        7:writeln(succ(x));
        end;
    end;
close(input); close(output);
end.

 

我在这里用了栈优化了新建和删除节点

将删除的节点压进一个栈 新建节点时优先从栈中取节点 栈空再新建

这样2000000的数据只需要300000的数组(其实可以更少)

不过如果2000000的插入就惨了 这里的优化是针对随机数据的

真正爆了也是RP问题

真正数据出到数组开不下 只能用栈优化一下 否则用就指针(调试得吐血)

我从一篇论文里才知道 Noi2005的Sequence是需要用栈优化的

否则会MLE的很惨 (据说不优化会用到100MB的内存)

如过碰到子树的删除可以将删除的子树根节点压入栈

新建节点取用时 先把节点弹出 如果所取节点有儿子就把再儿子压栈

这样免去了遍历子树 也可以算是lazy思想的小小应用

对于树这种递归结构 通常用栈可以解决很多问题

(栈果然和递归有着可怕的联系)

下面是splay tree的重头戏

也就是伸展树的灵魂——splay操作牛B的地方

我们先看splay是如何解决区间问题的

区间问题的操作无非是如下几个

　　区间查询(最值 求和...)

　　区间修改(统一加一个数 统一乘一个数...)

　　区间插入(插入一段或一个值)

　　区间删除(删除一段或一个值)

　　区间交换

前2种操作 线段树可以很好的处理

后3种就是要用伸展树解决的了

如果splay树的中序遍历是原序列

对于区间[x,y]我们先把x-1旋转到根

再把y+1转到根的右子节点
 

 (当然这里的x和y是节点的rank值 而不是节点内存的n值

也就是节点在原序列的位置)

我们可以看到这时 根节点的右子节点的左子树就是[x,y]内所有的数了

于是区间操作就变得可行了 只要对这棵左子树下手就行了

我们结合pku3468来讨论一下

原题

　　http://acm.pku.edu.cn/JudgeOnline/problem?id=3468

题意

　　正如题目 相当simple 很裸

　　维护一个数列支持区间统一加一个数和查询区间和

用线段树解决很简单

运用一下lazy思想给所要修改的区间打一个标记

然后查询到时将标记下传 得到所查区间的值

代码贴一下

 

const    maxn=200000;
 var    l,r,ls,rs:array[1..maxn shl 1]of longint;
    v,s:array[1..maxn shl 1]of int64;
    m:array[1..maxn]of longint;
    n,tt,i,q,a,b,c:longint;
    ch,blank:char;
 procedure build(a,b:longint);
 var    x,mid:longint;
 begin
inc(tt); x:=tt;
l[x]:=a; r[x]:=b;
v[x]:=0;
 if b-a=1
    then begin
    s[x]:=m[b];
    exit; end
    else begin
    mid:=(a+b)shr 1;
    ls[x]:=tt+1; build(a,mid);
    rs[x]:=tt+1; build(mid,b);
    s[x]:=s[ls[x]]+s[rs[x]];
    end;
 end;
 procedure clean(x:longint);
 begin
if v[x]<>0
    then begin
    s[x]:=s[x]+(r[x]-l[x])*v[x];
            if ls[x]<>0 then v[ls[x]]:=v[ls[x]]+v[x];
    if rs[x]<>0 then v[rs[x]]:=v[rs[x]]+v[x];
    v[x]:=0;
    end;
end;
procedure insert(x,a,b,c:longint);
var    mid:longint;
begin
clean(x);
if (a<=l[x])and(r[x]<=b)
    then begin
    v[x]:=v[x]+c;
    exit;
    end;
mid:=(l[x]+r[x])shr 1;
if a<mid then insert(ls[x],a,b,c);
if mid<b then insert(rs[x],a,b,c);
clean(ls[x]); clean(rs[x]);
s[x]:=s[ls[x]]+s[rs[x]];
end;
function query(x,a,b:longint):int64;
var    mid:longint;
    ans:int64;
begin
clean(x);
if (a<=l[x])and(r[x]<=b)
    then begin
    query:=s[x];
    exit;
    end;
ans:=0;
mid:=(l[x]+r[x])shr 1;
if a<mid then ans:=ans+query(ls[x],a,b);
if mid<b then ans:=ans+query(rs[x],a,b);
clean(ls[x]); clean(rs[x]);
s[x]:=s[ls[x]]+s[rs[x]];
query:=ans;
end;
begin
assign(input,'simple.in'); reset(input);
assign(output,'simple.out'); rewrite(output);
readln(n,q);
for i:=1 to n do
    read(m[i]);
tt:=0;
build(0,n);
readln;
for i:=1 to q do
    begin
    read(ch); read(blank);
    case ch of
        'Q':    begin
            readln(a,b);
            writeln(query(1,a-1,b));
            end;
        'C':    begin
            readln(a,b,c);
            insert(1,a-1,b,c);
            end;
        end;
    end;
close(input); close(output);
end.

顺便给一个加强版 支持区间乘一个数

 

 

const    maxn=100000;
var    l,r,ls,rs:array[1..maxn shl 1-1]of longint;
    u,v,s:array[1..maxn shl 1-1]of int64;
            m:array[1..maxn]of longint;
            n,q,tt,i,a,b,c:longint;
    ch,blank:char;
procedure build(a,b:longint);
var    mid,x:longint;
begin
inc(tt); x:=tt;
l[x]:=a; r[x]:=b;
u[x]:=0; v[x]:=1;
if b-a=1
    then s[x]:=m[b]
    else begin
    mid:=(a+b)shr 1;
    ls[x]:=tt+1; build(a,mid);
    rs[x]:=tt+1; build(mid,b);
    s[x]:=s[ls[x]]+s[rs[x]];
    end;
end;
procedure clean(x:longint);
begin
if (u[x]<>0)or(v[x]<>1)
    then begin
    s[x]:=s[x]*v[x]+u[x]*(r[x]-l[x]);
    if ls[x]<>0
        then begin
        v[ls[x]]:=v[ls[x]]*v[x];
        u[ls[x]]:=u[ls[x]]*v[x]+u[x];
        end;
    if rs[x]<>0
        then begin
        v[rs[x]]:=v[rs[x]]*v[x];
        u[rs[x]]:=u[rs[x]]*v[x]+u[x];
        end;
    v[x]:=1; u[x]:=0;
    end;
end;
procedure mult(x,a,b,c:longint);
var    mid:longint;
begin
clean(x);
if (a<=l[x])and(r[x]<=b)
    then begin
    u[x]:=u[x]*c;
    v[x]:=v[x]*c;
    exit; end;
mid:=(l[x]+r[x])shr 1;
if a<mid then mult(ls[x],a,b,c);
if mid<b then mult(rs[x],a,b,c);
clean(ls[x]); clean(rs[x]);
s[x]:=s[ls[x]]+s[rs[x]];
end;
procedure plus(x,a,b,c:longint);
var    mid:longint;
begin
clean(x);
if (a<=l[x])and(r[x]<=b)
    then begin
    u[x]:=u[x]+c;
    exit; end;
mid:=(l[x]+r[x])shr 1;
if a<mid then plus(ls[x],a,b,c);
if mid<b then plus(rs[x],a,b,c);
clean(ls[x]); clean(rs[x]);
s[x]:=s[ls[x]]+s[rs[x]];
end;
function query(x,a,b:longint):int64;
var    mid:longint;
    ans:int64;
begin
clean(x);
if (a<=l[x])and(r[x]<=b)
    then begin
    query:=s[x];
    exit; end;
ans:=0;
mid:=(l[x]+r[x])shr 1;
if a<mid then ans:=ans+query(ls[x],a,b);
if mid<b then ans:=ans+query(rs[x],a,b);
query:=ans;
clean(ls[x]); clean(rs[x]);
s[x]:=s[ls[x]]+s[rs[x]];
end;
begin
assign(input,'ssimple.in'); reset(input);
assign(output,'ssimple.out'); rewrite(output);
readln(n,q);
for i:=1 to n do
    read(m[i]);
readln;
tt:=0;
build(0,n);
for i:=1 to q do
    begin
    read(ch); read(blank);
    case ch of
        'Q':    begin
            readln(a,b);
            writeln(query(1,a-1,b));
            end;
        'M':    begin
            readln(a,b,c);
            mult(1,a-1,b,c);
            end;
        'P':    begin
            readln(a,b,c);
            plus(1,a-1,b,c);
            end;
        end;
    end;
close(input); close(output);
end.

那么用splay来解决怎么做呢

 

我们给每个节点记录一下sum值和n值 sum值就是子树的和

还要给一个标记域 以便运用lazy思想 标记域存个delta表示子树的值都得加delta

旋转的时候维护好sum和size就行了

这样splay操作就不仅是提根 也顺便维护了路径上的所有节点

对于区间[x,y]修改 查询rank为x-1和y+1的节点 也就是select操作

然后我们把x-1旋转到根 再把y+1转到根的右子节点

我们就得到根右子节点的左子树是区间[x,y]

运用lazy思想给这个子树的根节点左右打个标记即可

然后更新一下根节点的值 继续向上更新父亲和祖父节点

也就是更新根节点和根节点的右子节点

对于区间查询 也是如此

利用splay得到一棵能代表区间的子树

查询子树的根节点就是答案

贴个代码

 

const    max=200000;
    maxn=120000;
var    l,r,f:array[0..max]of longint;
    s,d,sum,n:array[0..max]of int64;
    dat:array[1..maxn]of longint;
    stack:array[1..max]of longint;
    m,q,tt,root,i,a,b,c,top:longint;
    ch,blank:char;
procedure down(x:longint);
begin
if x=0 then exit;
if l[x]<>0 then d[l[x]]:=d[l[x]]+d[x];
if r[x]<>0 then d[r[x]]:=d[r[x]]+d[x];
sum[x]:=sum[x]+d[x]*s[x];
n[x]:=n[x]+d[x];
d[x]:=0;
end;
procedure zig(var x:longint);
var    y:longint;
begin
down(x); down(l[x]);
y:=l[x]; l[x]:=r[y]; r[y]:=x;
f[y]:=f[x]; f[x]:=y;
if l[x]<>0 then f[l[x]]:=x;
s[y]:=s[x]; s[x]:=s[l[x]]+s[r[x]]+1;
down(r[x]); down(l[x]);
sum[y]:=sum[x]; sum[x]:=sum[l[x]]+sum[r[x]]+n[x];
x:=y;
end;
procedure zag(var x:longint);
var    y:longint;
begin
down(x); down(r[x]);
y:=r[x]; r[x]:=l[y]; l[y]:=x;
f[y]:=f[x]; f[x]:=y;
if r[x]<>0 then f[r[x]]:=x;
s[y]:=s[x]; s[x]:=s[l[x]]+s[r[x]]+1;
down(r[x]); down(l[x]);
sum[y]:=sum[x]; sum[x]:=sum[l[x]]+sum[r[x]]+n[x];
x:=y;
end;
procedure splay(x:longint; var S:longint);
begin
while f[x]<>f[S] do
    if l[f[x]]=x
        then begin
        if f[x]=S
            then zig(S)
            else if l[f[f[x]]]=f[x]
                then zig(l[f[f[x]]])
                else zig(r[f[f[x]]]);
        end
        else begin
        if f[x]=S
            then zag(S)
            else if l[f[f[x]]]=f[x]
                then zag(l[f[f[x]]])
                else zag(r[f[f[x]]]);
        end;
end;
procedure newnode(var x:longint);
begin
if top>0
    then begin x:=stack[top]; dec(top); end
    else begin inc(tt); x:=tt; end;
l[x]:=0; r[x]:=0; f[x]:=0;
end;
procedure recnode(var x:longint);
begin
inc(top); stack[top]:=x;
end;
procedure build(var x:longint; a,b:longint);
var    mid:longint;
begin
if a>b then exit;
newnode(x);
mid:=(a+b)shr 1; n[x]:=dat[mid];
build(l[x],a,mid-1); build(r[x],mid+1,b);
if l[x]<>0 then f[l[x]]:=x;
if r[x]<>0 then f[r[x]]:=x;
sum[x]:=sum[l[x]]+sum[r[x]]+n[x];
s[x]:=s[l[x]]+s[r[x]]+1;
end;
function select(x,k:longint):longint;
begin
if s[l[x]]+1=k then exit(x);
if k<=s[l[x]] then select:=select(l[x],k)
    else select:=select(r[x],k-s[l[x]]-1);
end;
procedure plus(a,b,c:longint);
var    x,y:longint;
begin
x:=select(root,a-1);
y:=select(root,b+1);
splay(x,root);
splay(y,r[root]);
y:=l[r[root]];
d[y]:=d[y]+c;
splay(y,root);
end;
function getsum(a,b:longint):int64;
var    x,y:longint;
begin
x:=select(root,a-1);
y:=select(root,b+1);
splay(x,root);
splay(y,r[root]);
y:=l[r[root]];
down(y);
getsum:=sum[y];
splay(y,root);
end;
begin
assign(input,'simple.in'); reset(input);
assign(output,'simple0.out'); rewrite(output);
readln(m,q);
dat[1]:=0; dat[m+2]:=0;
for i:=2 to m+1 do
    read(dat[i]);
readln;
s[0]:=0; tt:=0; root:=0;
build(root,1,m+2);
for i:=1 to q do
    begin
    read(ch); read(blank);
    case ch of
        'C':
            begin
            readln(a,b,c);
            plus(a+1,b+1,c);
            end;
        'Q':
            begin
            readln(a,b);
            writeln(getsum(a+1,b+1));
            end;
        end;
    end;
close(input);
close(output);
end.

具体测试中splay比线段树慢很多 也不是很好写

 

那我们为什么还要用splay呢

因为线段树有缺陷 线段树受不了插入和删除

我们再讨论一下pku3580 supermemo

(Noi那一个维护数列的题目 难度和这个差不多 <NOI2005 维护数列>

内容也差不多 就不细写了 注意上文提到的内存问题即可)

原题

　　http://acm.pku.edu.cn/JudgeOnline/problem?id=3580

题意

　　还是很裸 不过配的上super这个词

1. ADD x y D: Add D to each number in sub-sequence {A_x ... A_y}. For example, performing "ADD 2 4 1" on {1, 2, 3, 4, 5} results in {1, 3, 4, 5, 5}
2. REVERSE x y: reverse the sub-sequence {A_x ... A_y}. For example, performing "REVERSE 2 4" on {1, 2, 3, 4, 5} results in {1, 4, 3, 2, 5}
3. REVOLVE x y T: rotate sub-sequence {A_x ... A_y} T times. For example, performing "REVOLVE 2 4 2" on {1, 2, 3, 4, 5} results in {1, 3, 4, 2, 5}
4. INSERT x P: insert P after A_x. For example, performing "INSERT 2 4" on {1, 2, 3, 4, 5} results in {1, 2, 4, 3, 4, 5}
5. DELETE x: delete A_x. For example, performing "DELETE 2" on {1, 2, 3, 4, 5} results in {1, 3, 4, 5}
6. MIN x y: query the participant what is the minimum number in sub-sequence {A_x ... A_y}. For example, the correct answer to "MIN 2 4" on {1, 2, 3, 4, 5} is 2

　　英文很好懂的 不翻译了

说来很惭愧 调了2天才AC 唉 不堪回首

　　add已经在上面讨论过了

　　reverse也是用的lazy标记的方法 记录一个布尔变量 表示当前子树需不需要交换左右儿子(下传时是用not运算而不是直接赋值)

　　min操作要求我们维护一个min域 (注意在add的时候直接加min 千万不要从儿子处更新)

　　insert 先把x转到根 再把x+1转到右子节点 给右子节点的左儿子挂个新节点(注意要向上更新)

　　delete 先把x转到根 再把x+2转到右子节点 砍了右子节点的左儿子(注意要向上更新)

　　revolve本质是交换区间 我们先把2个区间分离到出来 然后经过一系列的指针操作解决(相当繁琐 注意细节 给个图好看着写代码)

　　假设交换区间[a,b][b+1,c] 如图所示

　　 -->-->  -->

最后贴一下我的代码

 

const    maxn=200000;
    inf=maxlongint shr 1;
var    l,r,s,f,dat:array[0..maxn]of longint;
    n,d,min:array[0..maxn]of int64;
    w:array[0..maxn]of boolean;
    i,g,x,y,k,m,q,delta,root,tt,temp:longint;
    st:string;
    ch:char;
procedure down(x:longint);
var     temp:longint;
begin
if d[x]<>0
    then begin
    if l[x]<>0 then d[l[x]]:=d[l[x]]+d[x];
    if r[x]<>0 then d[r[x]]:=d[r[x]]+d[x];
    n[x]:=n[x]+d[x]; min[x]:=min[x]+d[x];
    d[x]:=0;
    end;
if w[x]
    then begin
    if l[x]<>0 then w[l[x]]:=not w[l[x]];
    if r[x]<>0 then w[r[x]]:=not w[r[x]];
    temp:=l[x]; l[x]:=r[x]; r[x]:=temp;
    w[x]:=false;
    end;
end;
procedure out(x:longint);
begin
if x=0 then exit;
down(x);
out(l[x]);
if n[x]<>inf then write(n[x],' ');
out(r[x]);
end;
procedure update(x:longint);
begin
if x=0 then exit;
down(l[x]); down(r[x]);
s[x]:=s[l[x]]+s[r[x]]+1;
if min[l[x]]<min[r[x]]
    then min[x]:=min[l[x]]
    else min[x]:=min[r[x]];
if n[x]<min[x] then min[x]:=n[x];
end;
procedure zig(var x:longint);
var    y:longint;
begin
y:=l[x]; l[x]:=r[y]; r[y]:=x;
f[y]:=f[x]; f[x]:=y; if l[x]<>0 then f[l[x]]:=x;
update(x); update(y); x:=y;
end;
procedure zag(var x:longint);
var    y:longint;
begin
y:=r[x]; r[x]:=l[y]; l[y]:=x;
f[y]:=f[x]; f[x]:=y; if r[x]<>0 then f[r[x]]:=x;
update(x); update(y); x:=y;
end;
procedure splay(x:longint; var O:longint);
begin
while f[x]<>f[O] do
    if l[f[x]]=x
        then begin
        if f[x]=O
            then zig(O)
            else if l[f[f[x]]]=f[x]
                then zig(l[f[f[x]]])
                else zig(r[f[f[x]]]);
        end
        else begin
        if f[x]=O
            then zag(O)
            else if l[f[f[x]]]=f[x]
                then zag(l[f[f[x]]])
                else zag(r[f[f[x]]]);
        end;
end;
procedure build(var x:longint; a,b:longint);
var    mid:longint;
begin
if a>b then exit;
inc(tt); x:=tt;
mid:=(a+b)shr 1; n[x]:=dat[mid];
build(l[x],a,mid-1); build(r[x],mid+1,b);
if l[x]<>0 then f[l[x]]:=x;
if r[x]<>0 then f[r[x]]:=x;
update(x);
end;
function select(x,k:longint):longint;
begin
down(x);
if s[l[x]]+1=k then exit(x);
if k<=s[l[x]] then select:=select(l[x],k)
    else select:=select(r[x],k-s[l[x]]-1);
end;
begin
assign(input,'memo.in'); reset(input);
assign(output,'memo.out'); rewrite(output);
readln(m);
dat[1]:=inf; dat[m+2]:=inf;
for i:=2 to m+1 do
    readln(dat[i]);
root:=0; tt:=0; min[0]:=inf; s[0]:=0;
build(root,1,m+2);
readln(q);
//out(root); writeln;
for g:=1 to q do
    begin
    ch:='^'; st:='';
    while ch<>' ' do
        begin
        st:=st+ch;
        read(ch);
        end;
    if st='^ADD'
        then begin
        readln(x,y,delta); inc(x); inc(y);
        x:=select(root,x-1); y:=select(root,y+1);
        splay(x,root); splay(y,r[root]);
        x:=l[r[root]];
        d[x]:=d[x]+delta; down(x);
        update(r[root]); update(root);
        end;
    if st='^INSERT'
        then begin
        readln(x,delta); inc(x);
        y:=select(root,x+1);
        x:=select(root,x);
        splay(x,root); splay(y,r[root]);
        inc(tt); l[r[root]]:=tt; x:=l[r[root]];
        n[x]:=delta; min[x]:=n[x]; s[x]:=1; f[x]:=r[root];
        update(r[root]); update(root);
        end;
    if st='^DELETE'
        then begin
        readln(x); inc(x);
        y:=select(root,x+1); x:=select(root,x-1);
        splay(x,root); splay(y,r[root]);
        l[r[root]]:=0;
        update(r[root]); update(root);
        end;
    if st='^REVERSE'
        then begin
        readln(x,y); inc(x); inc(y);
        x:=select(root,x-1); y:=select(root,y+1);
        splay(x,root); splay(y,r[root]);
        x:=l[r[root]];
        w[x]:=not w[x]; down(x);
        update(r[root]); update(root);
        end;
    if st='^REVOLVE'
        then begin
        readln(x,y,k); inc(x); inc(y);
        if x=y then begin {out(root);writeln;} continue; end;
        k:=k mod (y-x+1);
        if k=0 then begin {out(root);writeln;} continue; end;
        k:=select(root,y-k); x:=select(root,x-1); y:=select(root,y+1);
        splay(k,root); splay(x,l[root]); splay(y,r[root]);
        x:=r[l[root]]; y:=l[r[root]];
        r[l[root]]:=0; l[r[root]]:=0;
        f[x]:=0; f[y]:=0;
        r[l[root]]:=y; if y<>0 then f[y]:=l[root];
        update(l[root]);
        y:=l[root]; l[root]:=x; if x<>0 then f[x]:=root;
        update(r[root]); update(l[root]); update(root);
        x:=select(root,1);
        splay(x,root);
        l[root]:=y; f[y]:=root;
        update(root);
        end;
    if st='^MIN'
        then begin
        readln(x,y); inc(x); inc(y);
        x:=select(root,x-1);
        y:=select(root,y+1);
        splay(x,root); splay(y,r[root]);
        x:=l[r[root]];
        down(x); writeln(min[x]);
        continue;
        end;
    //out(root);writeln;
    end;
close(input); close(output);
end.

 

splay很强大 不过不是强在高度 而是强在灵活度

 

BOB HAN原创 转载请注明出处