[PKU 3481][Noi 2004 Cashier]伸展树Splay & 平衡树SBT(上)

{

本文主要介绍一下伸展树与平衡树SBT

平衡树应用广泛 效率极高（最坏为Logn）

是实现优先队列 数据字典的不二选择

伸展树因其独有的Splay操作

可以应对很多线段树难以处理的区间问题

而不仅仅是用作一棵排序二叉树来处理数据

而且伸展树效率也很高 达到了均摊Logn的级别

}

先讲平衡树SBT

CQF大神的SBT我已经膜拜好久了

程序也差不多看懂了

果然是大神的程序 很精简

有些地方在论文里没有解释

在这里讲一下

先是旋转(zig|zag)

 

procedure right_rotate(var t:longint);//右旋 使用变量参数 方便操作
 begin
   k:=left[t];
   left[t]:=right[k];
   right[k]:=t;
   s[k]:=s[t];
   s[t]:=s[left[t]]+s[right[t]]+1;
   t:=k;//根节点改变 更新变参
 end;

procedure left_rotate(var t:longint);//左旋
 begin
   k:=right[t];
   right[t]:=left[k];
   left[k]:=t;
   s[k]:=s[t];
   s[t]:=s[left[t]]+s[right[t]]+1;
   t:=k;
 end;

 

由于两个旋转是对称的 就单讲一个右旋

前三句话很好理解 是旋转需要的指针变动

第6行更新新的根节点k的size域 就是原来根节点t的size

第7行更新t节点的size域 此时儿子已经改变且size域已经求好 所以通过儿子计算即可

最后一行比较难理解{t:=k;}

这里因为t是传的变量参数 相当于是传递的记录当前子树的根的变量

于是k旋转上去之后 子树的根也应当自动更新

(空讲不一定清楚 在后文讨论其他函数的时候会再次具体说明)

下来是插入(Insert)

 

procedure insert(var t,v:longint);//同样使用变参
 begin
   if t=0 then begin
      inc(tt);
      t:=tt;//使用变参之后 节点父亲的儿子指针也会同时改变
      key[t]:=v;
      s[t]:=1;
      left[t]:=0;
      right[t]:=0; //到达边界 新建节点
   end
   else begin
      inc(s[t]);//注意更新size
      if v<key[t] then
         insert(left[t],v)
      else
         insert(right[t],v);
      maintain(t,v>=key[t]);
   end;
 end;

第3行 如果当前子树为空树则新建节点为其根

 

其中有一句{t:=tt;}这一句是有用的

我们看到t是传递的变量 这个变量是什么呢?

递归退回到上一层 我们看到是l[x]或r[x]

这里改变t为tt 事实上就是改变l[x]或r[x] 这里也就是传递变参的高明之处

不用记录父亲 直接可以改变父亲节点的儿子指针

这样代码便会简洁许多

回到上面旋转留下的问题

由于插入以及后面的删除 maintain函数都使用了变参

旋转作为最基础的操作也应当使用变参

事实上 利用变参不仅可以传递值 还传递指针的特性

可以使很多代码得以简化 但是对思考的细致有要求

下来考虑maintain函数

 

procedure maintain(var t:longint;flag:boolean);//保持SBT性质
 begin
   if flag=false then//用boolean变量flag决定调整左子树还是右子树
      if s[left[left[t]]]>s[right[t]] then
         right_rotate(t)
      else
         if s[right[left[t]]]>s[right[t]] then begin
            left_rotate(left[t]);
            right_rotate(t);
         end
         else
            exit
   else
      if s[right[right[t]]]>s[left[t]] then
         left_rotate(t)
      else
         if s[left[right[t]]]>s[left[t]] then begin
            right_rotate(right[t]);
            left_rotate(t);
         end//此处各种情况在论文里有详细说明
         else
            exit;//无需调整 直接退出
   maintain(left[t],false);//递归调整性质可能被破坏的子树
   maintain(right[t],true);//优化：只调整左子树的左子树和右子树的右子树
   maintain(t,true);
   maintain(t,false);//调整自身
 end;

maintain在论文里讲的很详细 不再细说

 

这个函数能达到O(1)的复杂度

(膜拜CQF大神 怎么想到的)

下面是删除(Delete)

 

function delete(var t:longint;v:longint):longint;
　　//这里的删除必定会删掉一个节点并返回这个节点
 begin
   dec(s[t]);
   if (v=key[t])or(v<key[t])and(left[t]=0)or(v>key[t])and(right[t]=0) then begin
      delete:=key[t];//到达边界 删除一个节点 返回值
      if (left[t]=0)or(right[t]=0) then
         t:=left[t]+right[t]-0//直接删除
      else
         key[t]:=delete(left[t],key[t]+1);//从右子树中取下一个最大的节点取代当前节点
   end
   else
      if v<key[t] then
         delete:=delete(left[t],v)
      else
         delete:=delete(right[t],v);
 end;//这里不用maintain 因为删除不增加高度

CQF的删除我一开始也没看懂

 

我一直在想删除一定会删掉一个节点 不会出错么

事实上这种"暴力"的删法相当巧妙

至于怕删错 用下面的find函数特判即可

第一句话 由于必定删除一个节点 不由分说 讲这个子树的size减1

　　　　我们看到 如果不是必定删除一个的话 size值减不减一还是个麻烦的事

第2行:有几种情况是必须在这里把根节点砍掉的

　　比如要删的值小于当前节点而左子树为空

　　要删的值大于当前节点而右子树为空

　　抑或是当前节点是要删的节点

我们注意到这样我们删的节点的值必然是最接近于我们想删的值的

下面分情况讨论怎么删

　　一是只有一个子树 直接把儿子连到父亲即可

　　二是由2个子树 就从左子树挖一个最大的填到当前子树根上

　　　　根据上面最接近于我们想删的值的结论

　　　　所以递归调用删除key[x]+1必然是删的左子树最大节点

第11行 不符合上面任何一个情况 递归删除

最后由于删除不增加高度 maintain也可以省了

下面是各个查询函数(Find Rank Select Pred Succ)

 

function find(var t,v:longint):boolean;//以下可以不用变参 因为是查询操作
 begin
   if t=0 then
      exit(false);//没有查询到
   if v<key[t] then
      find:=find(left[t],v)
   else
      find:=(key[t]=v)or find(right[t],v);//递归
 end;
 function rank(var t,v:longint):longint;
 begin
   if t=0 then
      exit(1);//子树为空时 所查节点排位自然为1
   if v<=key[t] then
      rank:=rank(left[t],v)
   else
      rank:=s[left[t]]+1+rank(right[t],v);//向右子树查询 注意右子树中的排位不是真是排位
 end;
 function select(var t:longint;k:longint):longint;
 begin
   if k=s[left[t]]+1 then
      exit(key[t]);//查询节点为根
   if k<=s[left[t]] then
      select:=select(left[t],k)
   else
      select:=select(right[t],k-1-s[left[t]]);//向右子树查询 注意同rank
 end;
 function pred(var t,v:longint):longint;
 begin
   if t=0 then
      exit(v);//到达边界 即 所查节点没有前驱直接返回所查节点
   if v<=key[t] then
      pred:=pred(left[t],v)//前驱必在左子树上
   else begin
      pred:=pred(right[t],v);
      if pred=v then//在右子树上没有前驱 即 所查节点为右子树上最小
         pred:=key[t];//前驱为根
   end;
 end;
 function succ(var t,v:longint):longint;
 begin
   if t=0 then
      exit(v);
   if key[t]<=v then
      succ:=succ(right[t],v)
   else begin
      succ:=succ(left[t],v);
      if succ=v then
         succ:=key[t];//后继和查前驱类似
   end;
 end;

注释比较清楚 就不细写了

 

需要注意查询的边界条件比如Rank的边界:空树中返回1

实质上Rank是将所查节点假设插入后的rank值返回

比如{1,2,4,5}中 6的rank是5,0的rank是1,3的rank是3,4的rank是3

自然而然 在一个空集{}中任何数的rank都是1

succ和pred在遇到空树时返回v

也是假设插入后取前驱后继

当为最大最小值时直接返回最大最小值

比如{1,2,4,5}中 6的pred是5,0的pred是0,3的pred是2,4的pred是2

所以{}中 任何数的前驱后继是其本身

最后是主函数(main)

 

begin
   tt:=0;//总节点数
   t:=0;//用t纪录数组中的当前根节点 根节点作为变参传递时 根据需要会随时改变（向前移动）
   s[0]:=0;//空点初始size为0
   for q:=1 to q do
      case a[q] of//由于删除等操作必定删除一个节点或返回值 有必要时应先确定所查节点是否在树中
         1:insert(t,b[q]);
         2:if find(t,b[q]) then delete(t,b[q]);
         3:writeln(find(t,b[q]));
         4:writeln(rank(t,b[q]));
         5:writeln(select(t,b[q]));
         6:writeln(pred(t,b[q]));
         7:writeln(succ(t,b[q]));
      end;
end;
begin
   assign(input,'input.txt');
   assign(output,'ans0.txt');
   reset(input);
   rewrite(output);
   init;
   work;
   close(input);
   close(output);
end.

注释清楚 注意s[0]与t和tt的含义

 

最后给出完整的陈启峰官方SBT代码

 

//http://www.nocow.cn/index.php/SBT#.E6.80.A7.E8.83.BD.E5.88.86.E6.9E.90
//cqf大神的官方源码
//注释写得不一定好 但是是我看了很长时间代码+论文才理解的
program CQF_SBT;
const maxn=2000000;//n适当大点 因为整棵树会在数组里向前移动
var key,s,left,right,a,b:array[0..maxn] of longint;
    tt,q:longint;
procedure init;
begin
   readln(q);
   for q:=1 to q do
      readln(a[q],b[q]);
end;
procedure work;
var t,k:longint;
procedure right_rotate(var t:longint);//右旋 使用变量参数 方便操作
begin
   k:=left[t];
   left[t]:=right[k];
   right[k]:=t;
   s[k]:=s[t];
   s[t]:=s[left[t]]+s[right[t]]+1;
   t:=k;//根节点改变 更新变参
end;
procedure left_rotate(var t:longint);//左旋
begin
   k:=right[t];
   right[t]:=left[k];
   left[k]:=t;
   s[k]:=s[t];
   s[t]:=s[left[t]]+s[right[t]]+1;
   t:=k;
end;
procedure maintain(var t:longint;flag:boolean);//保持SBT性质
begin
   if flag=false then//用boolean变量flag决定调整左子树还是右子树
      if s[left[left[t]]]>s[right[t]] then
         right_rotate(t)
      else
         if s[right[left[t]]]>s[right[t]] then begin
            left_rotate(left[t]);
            right_rotate(t);
         end
         else
            exit
   else
      if s[right[right[t]]]>s[left[t]] then
         left_rotate(t)
      else
         if s[left[right[t]]]>s[left[t]] then begin
            right_rotate(right[t]);
            left_rotate(t);
         end//此处各种情况在论文里有详细说明
         else
            exit;//无需调整 直接退出
   maintain(left[t],false);//递归调整性质可能被破坏的子树
   maintain(right[t],true);//优化：只调整左子树的左子树和右子树的右子树
   maintain(t,true);
   maintain(t,false);//调整自身
end;
procedure insert(var t,v:longint);//同样使用变参
begin
   if t=0 then begin
      inc(tt);
      t:=tt;//使用变参之后 节点父亲的儿子指针也会同时改变
      key[t]:=v;
      s[t]:=1;
      left[t]:=0;
      right[t]:=0; //到达边界 新建节点
   end
   else begin
      inc(s[t]);//注意更新size
      if v<key[t] then
         insert(left[t],v)
      else
         insert(right[t],v);
      maintain(t,v>=key[t]);
   end;
end;
function delete(var t:longint;v:longint):longint;//这里的删除必定会删掉一个节点并返回这个节点
begin
   dec(s[t]);
   if (v=key[t])or(v<key[t])and(left[t]=0)or(v>key[t])and(right[t]=0) then begin
      delete:=key[t];//到达边界 删除一个节点 返回值
      if (left[t]=0)or(right[t]=0) then
         t:=left[t]+right[t]-0//直接删除
      else
         key[t]:=delete(left[t],key[t]+1);//从右子树中取下一个最大的节点取代当前节点
   end
   else
      if v<key[t] then
         delete:=delete(left[t],v)
      else
         delete:=delete(right[t],v);
end;//这里不用maintain 因为删除不增加高度
function find(var t,v:longint):boolean;//以下可以不用变参 因为是查询操作
begin
   if t=0 then
      exit(false);//没有查询到
   if v<key[t] then
      find:=find(left[t],v)
   else
      find:=(key[t]=v)or find(right[t],v);//递归
end;
function rank(var t,v:longint):longint;
begin
   if t=0 then
      exit(1);//子树为空时 所查节点排位自然为1
   if v<=key[t] then
      rank:=rank(left[t],v)
   else
      rank:=s[left[t]]+1+rank(right[t],v);//向右子树查询 注意右子树中的排位不是真是排位
end;
function select(var t:longint;k:longint):longint;
begin
   if k=s[left[t]]+1 then
      exit(key[t]);//查询节点为根
   if k<=s[left[t]] then
      select:=select(left[t],k)
   else
      select:=select(right[t],k-1-s[left[t]]);//向右子树查询 注意同rank
end;
function pred(var t,v:longint):longint;
begin
   if t=0 then
      exit(v);//到达边界 即 所查节点没有前驱直接返回所查节点
   if v<=key[t] then
      pred:=pred(left[t],v)//前驱必在左子树上
   else begin
      pred:=pred(right[t],v);
      if pred=v then//在右子树上没有前驱 即 所查节点为右子树上最小
         pred:=key[t];//前驱为根
   end;
end;
function succ(var t,v:longint):longint;
begin
   if t=0 then
      exit(v);
   if key[t]<=v then
      succ:=succ(right[t],v)
   else begin
      succ:=succ(left[t],v);
      if succ=v then
         succ:=key[t];//后继和查前驱类似
   end;
end;
begin
   tt:=0;//总节点数
   t:=0;//用t纪录数组中的当前根节点 根节点作为变参传递时 根据需要会随时改变（向前移动）
   s[0]:=0;//空点初始size为0
   for q:=1 to q do
      case a[q] of//由于删除等操作必定删除一个节点或返回值 有必要时应先确定所查节点是否在树中
         1:insert(t,b[q]);
         2:if find(t,b[q]) then delete(t,b[q]);
         3:writeln(find(t,b[q]));
         4:writeln(rank(t,b[q]));
         5:writeln(select(t,b[q]));
         6:writeln(pred(t,b[q]));
         7:writeln(succ(t,b[q]));
      end;
end;
begin
   assign(input,'input.txt');
   assign(output,'ans0.txt');
   reset(input);
   rewrite(output);
   init;
   work;
   close(input);
   close(output);
end.

 

Noi2004郁闷的出纳员是可以运用SBT解决的

只需注意工资是整体上浮下调的

我们累加工资的调整代数和记录差值delta

比如工资涨了5 又降了7 delta=-2

当前工资底线需要时时改变 总工资涨10 底线就要扣10 而员工工资不需整体改变

比如原来工资底线为8 现在要按8-(-2)=10来算

而对于新来的员工 出始工资统一减delta即可

还要注意要删除的是一棵一棵的子树 不要一个一个去删

代码如下

 

const   maxn=200000;
var    l,r,s,n:array[0..maxn]of longint;
    k,i,tt,ans,t,d,m,min:longint;
    ch:char;
procedure zig(var x:longint);
var y:longint;
begin
y:=l[x]; l[x]:=r[y]; r[y]:=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;
s[y]:=s[x]; s[x]:=s[l[x]]+s[r[x]]+1;
x:=y;
end;
procedure maintain(var x:longint; flag:boolean);
begin
if flag
    then begin
    if s[l[l[x]]]>s[r[x]] then zig(x)
        else if s[l[r[x]]]>s[r[x]]
            then begin zag(l[x]); zig(x); end
            else exit;
    end
    else begin
    if s[r[r[x]]]>s[l[x]] then zag(x)
        else if s[r[l[x]]]>s[l[x]]
            then begin zig(r[x]); zag(x); end
            else exit;
    end;
maintain(l[x],true); maintain(r[x],false);
maintain(x,true);maintain(x,false);
end;
procedure insert(var x:longint; v:longint);
begin
if x=0
    then begin
    inc(tt); x:=tt;
    n[x]:=v; s[x]:=1;
    end
    else begin
    inc(s[x]);
    if v<n[x] then insert(l[x],v)
        else insert(r[x],v);
    maintain(x,v<=n[x]);
    end;
end;
function delete(var x:longint):longint;
var     y:longint;
begin
if x=0 then exit(0);
if n[x]<min
    then begin
    y:=s[l[x]]+1; l[x]:=0;
    y:=y+delete(r[x]);
        s[x]:=s[x]-y;
    s[r[x]]:=s[x]; x:=r[x];
    end
    else begin
    y:=delete(l[x]);
    s[x]:=s[x]-y;
    end;
delete:=y;
end;
function select(x,k:longint):longint;
begin
if k=s[l[x]]+1 then exit(n[x]+d);
if k<s[l[x]]+1 then exit(select(l[x],k))
    else exit(select(r[x],k-s[l[x]]-1));
end;
begin
assign(input,'cashier.in'); reset(input);
assign(output,'cashier.out'); rewrite(output);
d:=0; t:=0; tt:=0; s[0]:=0;
readln(m,min); ans:=0;
for i:=1 to m do
    begin
    readln(ch,k);
    case ch of
        'I':    begin
            ans:=ans+delete(t);
            if k-d>=min then insert(t,k-d);
            end;
        'A':    begin d:=d+k; min:=min-k; end;
        'S':    begin d:=d-k; min:=min+k; ans:=ans+delete(t); end;
        'F':    begin
            ans:=ans+delete(t);
            if s[t]<k then writeln(-1)
                else writeln(select(t,s[t]-k+1));
            end;
        end;
    end;
writeln(ans);
close(input); close(output);
end.

 

PKU3481是平衡树的裸题

伸展树有时候可以作为一个平衡树的替代

这题没有恶心数据 伸展树很快

给个伸展树代码吧 也算承上启下了

 

const    maxn=300000;
var    m,n,l,r,f:array[0..maxn]of longint;
    root,tt,k,p,q: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;
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:longint);
begin
while f[x]<>0 do
    if l[f[x]]=x
        then begin
        if f[f[x]]=0
            then zig(root)
            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[f[x]]=0
            then zag(root)
            else if l[f[f[x]]]=f[x]
                then zag(l[f[f[x]]])
                else zag(r[f[f[x]]]);
        end;
end;
procedure insert(var x:longint; k,p:longint);
var    i,j:longint;
begin
if x=0
    then begin
    inc(tt); x:=tt;
    n[x]:=p; m[x]:=k;
    exit;
    end;
j:=x;
while j<>0 do
    begin
    i:=j;
    if p<n[i] then j:=l[i] else j:=r[i];
    end;
inc(tt); j:=tt;
n[j]:=p; m[j]:=k;
f[j]:=i; l[j]:=0; r[j]:=0;
if p<n[i] then l[i]:=j else r[i]:=j;
splay(j);
end;
procedure deletemin(var x:longint);
var    i:longint;
begin
if x=0
    then begin writeln(0); exit; end;
i:=x;
while l[i]<>0 do i:=l[i];
writeln(m[i]);
splay(i);
x:=r[i]; f[r[i]]:=0;
end;
procedure deletemax(var x:longint);
var    i:longint;
begin
if x=0 
    then begin writeln(0); exit; end;
i:=x;
while r[i]<>0 do i:=r[i];
writeln(m[i]);
splay(i);
x:=l[i]; f[l[i]]:=0;
end;
begin
assign(input,'dq.in'); reset(input);
assign(output,'dq.out'); rewrite(output);
read(q);
tt:=0; root:=0;
while q<>0 do
    begin
    case q of
        1:    begin
            readln(k,p);
            insert(root,k,p);
            end;
        2:    deletemax(root);
        3:    deletemin(root);
        end;
    read(q);
    end;
close(input); close(output);
end.

 

 

在第二部分里我们介绍伸展树(Splay Tree)

先贴一下我自己写的伸展树代码 不长 也比较快

(我只用了单旋来Splay 但是好像不比双旋慢)

 

const    maxn=2000000;
var    l,r,f,n:array[0..maxn]of longint;
    order,root,m,i,k,tt,t: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;
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;
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;
procedure insert(var x:longint; v:longint);
var    i,j:longint;
begin
if x=0
    then begin
    inc(tt); x:=tt;
    l[x]:=0; r[x]:=0; f[x]:=0;
    n[x]:=v;
    exit; end;
j:=x;
while j<>0 do
    begin
    i:=j;
    if v<=n[i] then j:=l[i] else j:=r[i];
    end;
inc(tt); j:=tt;
if v<=n[i] then l[i]:=j else r[i]:=j;
f[j]:=i; n[j]:=v;
splay(j,root);
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;
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,root);
join(l[i],r[i]);
x:=l[i]; f[l[i]]:=0;
end;
begin
assign(input,'input.txt'); reset(input);
assign(output,'ans.txt'); rewrite(output);
readln(m);
tt:=0; root:=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));
        end;
    end;
close(input); close(output);
end.

 

BOB HAN原创 转载请注明出处