[知识点]平衡树之Splay_JK金坤

http://blog.sina.com.cn/u/1612891250

首页博文目录关于我

个人资料

微博

加好友发纸条

写留言加关注

博客等级：
博客积分：

博客访问：
关注人气：
获赠金笔：0支
赠出金笔：0支
荣誉徽章：

正文字体大小：大中小

[知识点]平衡树之Splay

(2015-07-18 09:06:16)

平衡树之 Splay 20150715

1、前言

这玩意儿真的搞了我好久，当然前一阵子一直都没有去管它，最近直接参照了YML（@YMDragon）的程序，感觉还是不错的，大概看得懂了，就是逻辑关系有点扯。好，废话不多说……

2、概念

平衡树的全称为：平衡二叉搜索树，功能很强大，带来的后果就是代码非常复杂。首先大家应该都知道二叉搜索树是什么了，那么前面加一个平衡的含义在于什么？根据读入顺序 { 80,30,90,20,40,35,38 }，我们先构造出一棵二叉搜索树，如图：

http://s12/mw690/001L9wH0gy6U0dKbkBZ6b&690

显然，这棵树长得有点畸形，其根节点左儿子部分节点明显过多。然而这不仅仅是看起来不舒服的问题，但我们要在树上进行某项询问或是某项操作的时候，如果深度过大，将会明显影响到时间效率，可以举一个极端的例子——如果我们构造出的是一条链，那么时间复杂度可想而知。而平衡的含义就出现了，让这棵树长得更像一棵树！在操作的时候能够提高效率。写平衡树的方式有很多种，如：Splay，Treap，红黑树和AVL树等等。Splay相比之下功能强大，代码量较大，今天的重点就在Splay。

3、Let's Splay

Splay的中文是伸展，并不清楚这有什么关系。Splay主要存在三种操作，下面一一介绍：

1.Zig操作

目标节点X是根节点的左（右）儿子，则将目标节点右（左）旋转至根节点。

http://s16/mw690/001L9wH0gy6TZxJzjf94f&690

2.Zig-zig操作

目标节点X不是根节点的子节点，且为其父节点的左（右）儿子，其父节点为其爷爷节点的左（右）儿子，则将目标节点X和其父节点先后进行右（左）旋。

http://s8/mw690/001L9wH0gy6U0d0Gi9Nb7&690

3.Zig-zag操作

目标节点X不是根节点的子节点，且为其父节点的左（右）儿子，其父节点为其爷爷节点的右（左）儿子，则将目标节点X进行右（左）旋，其父节点进行左（右）旋。http://s10/mw690/001L9wH0gy6TZxKiE3L79&690

具体操作的话，旋转多为自下而上的递归旋转，直到把目标节点旋转至根节点。

4、应用

平衡树存在一个共同作用也就是前文所提——平衡（废话呢）。但是今天的主题是Splay，之前也说过了它功能强大，那么强大在哪里？第一眼看题目你也许根本想不到要用Splay。现在我们来看一道神题：

http://s3/mw690/001L9wH0gy6U0e8Eftwe2&690

首先这是一道NOI2005的原题，BZOJ上没有给树数据范围，但是我想模拟的时间复杂度和空间复杂度一定是不能承受的。我也曾想到了链，但是感觉实现起来有点麻烦，那么这道题要用到的就是Splay。注意到，六大操作中，全部区间修改或区间询问，故我们先设当前操作对应区间为[x,y]（INSERT是个例外，可以认为y=x+1），首先我们将x旋转至根，然后在将y旋转至根，仔细思考一下，[x,y]目前在树中是如何分布的？必然是在同一棵子树之中。那么这样就好处理了，插入时即可类似于在这棵子树中构造（同等于最开始的输入环节），删除时直接将一棵子树清空（清空的具体操作：权值记为0，作标记；可能会遇到一个问题，如果删除操作过多，可能会造成过多的空间资源的浪费，这里我们可以考虑开一个队列，以便以后新插入节点时可以直接使用已经被删除的空间），修改权值和翻转的操作有点类似于线段树；询问的话，提前对于每一棵子树进行维护即可。

代码：

-----------------------------------------------------------------------------------------------------------------

#include cstdio
#include cstring
#include algorithm
#include queue

#define MAXN 500005
#define INF 1<<30
using namespace std;

struct Node
{
int son[2],l,r,m,k,t1,t2,s,sum,fa;
};

Node tree[MAXN];

int m,n,root,a[MAXN];
char now[10];
queue Q;

void plus1(int now,int val)
{
        if (!now) return;
        tree[now].k=val,tree[now].t1=1,tree[now].sum=tree[now].k*tree[now].s;
        if (tree[now].k>0) tree[now].l=tree[now].r=tree[now].m=tree[now].sum;
        else tree[now].l=tree[now].r=tree[now].m=tree[now].k;
}

void plus2(int now)
{
        if (!now) return;
        swap(tree[now].son[0],tree[now].son[1]),tree[now].t2^=1;
        swap(tree[now].l,tree[now].r);
}

void push(int now)
{
        if (!now) return;
        if (tree[now].t1) plus1(tree[now].son[0],tree[now].k),plus1(tree[now].son[1],tree[now].k),tree[now].t1=0;
        if (tree[now].t2) plus2(tree[now].son[0]),plus2(tree[now].son[1]),tree[now].t2=0;
}

void update(int now)
{
        if (!now) return;
        push(now);
        int lson=tree[now].son[0],rson=tree[now].son[1];
        tree[now].s=tree[lson].s+tree[rson].s+1;
        tree[now].sum=tree[lson].sum+tree[rson].sum+tree[now].k;
        tree[now].l=max(tree[lson].l,tree[lson].sum+tree[now].k+max(tree[rson].l,0));
        tree[now].r=max(tree[rson].r,tree[rson].sum+tree[now].k+max(tree[lson].r,0));
        tree[now].m=max(max(tree[lson].m,tree[rson].m),tree[now].k+max(tree[lson].r,0)+max(tree[rson].l,0));
}

void rotate(int now)
{
        int fa=tree[now].fa,gfa=tree[fa].fa,q=(tree[fa].son[1]==now),son=tree[now].son[q^1];
        if (gfa) tree[now].fa=gfa,tree[gfa].son[tree[gfa].son[1]==fa]=now;
        else tree[now].fa=0,root=now;
        tree[fa].son[q]=son; if (son) tree[son].fa=fa;
        tree[fa].fa=now,tree[now].son[q^1]=fa;
        update(fa),update(now);
// 让我来翻译一下这段话：
// 新建变量：我的爸爸，我爸爸的爸爸，“我是我爸的右儿子”判断，我的左（右）儿子；
// 如果我有爷爷，那么我的爸爸是我的爷爷，我的爷爷的儿子是我，左还是右取决于我爸爸是我爷爷的左还是右儿子；
// 如果我没爷爷，那么我爸爸也没有了，我就是你们的祖宗
// 我爸爸的儿子是我的儿子；如果我有儿子，那么我儿子的爸爸是我的爸爸
// 我爸爸的爸爸是我，我的左（右）儿子是我爸爸。

}

void splay(int now)
{
        int k=0;
        for (int x=now;x;x=tree[x].fa) { k++; a[k]=x; }
        for (int i=k;i>=1;i--) push(a[i]);
        while (tree[now].fa) rotate(now);
}

void build(int now,int l,int r)
{
        int mid=(l+r)>>1;
        if (l《mid) tree[now].son[0]=Q.front(),Q.pop(),build(tree[now].son[0],l,mid-1),tree[tree[now].son[0]].fa=now;
        scanf("%d",&tree[now].k);
        if (mid《r) tree[now].son[1]=Q.front(),Q.pop(),build(tree[now].son[1],mid+1,r),tree[tree[now].son[1]].fa=now;
        update(now);
}

int rank(int q)
{
        int now=root;
        while (now)
        {
                push(now);
                if (tree[tree[now].son[0]].s+1==q) return now;
                if (tree[tree[now].son[0]].s>=q) now=tree[now].son[0];
                else q-=tree[tree[now].son[0]].s+1,now=tree[now].son[1];
        }
        return 0;
}

void ins()
{
        int pos,tot,l,r,root; scanf("%d %d",&pos,&tot);
        l=rank(pos),r=rank(pos+1); splay(l),splay(r);
        root=Q.front(),Q.pop(),build(root,1,tot);
        if (l) tree[l].son[1]=root,tree[root].fa=l;
        else   tree[r].son[0]=root,tree[root].fa=r;
        update(l),update(r);
}

void DFS(int now)
{
        if (tree[now].son[0]) DFS(tree[now].son[0]);
        if (tree[now].son[1]) DFS(tree[now].son[1]);
        Q.push(now),memset(tree+now,0,sizeof(tree[now]));
}

void del()
{
        int pos,tot,l,r; scanf("%d %d",&pos,&tot);
        l=rank(pos-1),r=rank(pos+tot); splay(l),splay(r);
        if (l) DFS(tree[l].son[1]),tree[l].son[1]=0;
        else   DFS(tree[r].son[0]),tree[r].son[0]=0;
        update(l),update(r);
}

void makeSame()
{
        int pos,tot,c,l,r; scanf("%d %d %d",&pos,&tot,&c);
        l=rank(pos-1),r=rank(pos+tot); splay(l),splay(r);
        if (l) plus1(tree[l].son[1],c); else plus1(tree[r].son[0],c);
        update(l),update(r);
}

void reverse()
{
        int pos,tot,l,r; scanf("%d %d",&pos,&tot);
        l=rank(pos-1),r=rank(pos+tot); splay(l),splay(r);
        if (l) plus2(tree[l].son[1]); else if (r) plus2(tree[r].son[0]); else plus2(root);
        update(l),update(r);
}

int getSum()
{
        int pos,tot,l,r; scanf("%d %d",&pos,&tot);
        l=rank(pos-1),r=rank(pos+tot); splay(l),splay(r);
        if (l) return tree[tree[l].son[1]].sum;

else return tree[tree[r].son[0]].sum;
}

int maxSum() { return tree[root].m; }

void init()
{
        freopen("1500.in","r",stdin);
        freopen("1500.out","w",stdout);
        scanf("%d %d",&n,&m);
        for (int i=1;i<=MAXN;i++) Q.push(i);
        tree[0].l=tree[0].r=tree[0].m=-INF;
        root=Q.front(),Q.pop(),build(root,1,n);
}

int main()
{
        init();
        for (int i=1;i<=m;i++)
        {
                scanf("%s",&now);
                if (now[0]=='I') ins();
                else if (now[0]=='D') del();
                else if (now[2]=='K') makeSame();
                else if (now[0]=='R') reverse();
                else if (now[0]=='G') printf("%d\n",getSum());
                else printf("%d\n",maxSum());
        }
        return 0;
}

-----------------------------------------------------------------------------------------------------------------

阅读┊ 收藏 ┊ 喜欢 ▼ ┊打印┊举报/Report

前一篇：[题解]星球大战

后一篇：[总结+题解]NOI2015

新浪BLOG意见反馈留言板　欢迎批评指正