非常详细的Splay笔记

Splay笔记

0.
第一次接触是去年暑假一位巨佬学长介绍了这么一种神奇的平衡树，不过当时感觉没怎么完全弄懂。后来仔细想了一下个人感觉理解大有加深，这个数据结构确实非常优秀~~~传到优快云上来啦！
1. rotate()
To maintain the features of BST, we can get these basic rotation rules:

If A is the x son of B,

• B will become the !x son of A after the rotation.
• The !x son of B will still be the !x son of B after the rotation.
• The !x son of A will become the x son of B after the rotation.
• The x son of A will still be the x son of A after the rotation.

Before & After one rotation:

CODE:

bool dir(int x)
{
    return x==tree[tree[x].fa].ch[1];
}

void pushup(int x)
{
    tree[x].tot=tree[tree[x].ch[0]].tot+tree[tree[x].ch[1]].tot+1;
    return;
}

void connect(int x,int fa,int son)
{
    tree[x].fa=fa;
    tree[fa].ch[son]=x;
    return;
}

void rotate(int x)
{
    int y=tree[x].fa;
    if(y==root)
        root=x; //Remember to change the root. 
    int r=tree[y].fa;
    int yson=dir(x),rson=dir(y);
    int build=tree[x].ch[yson^1];
    connect(build,y,yson);
    connect(y,x,yson^1);
    connect(x,r,rson);
    pushup(y);
    pushup(x);
    return;
}

More explanations to the rotate function:

The left is one of the original relationship among the grandfather, the father, and the son. After rotate(x), the relationship among them becomes the right part of the picture.
Other situations can be gotten similarly by reflecting or reversing.
2. splay()

splay(x,to) is to rotate x continuously until it becomes to’s son.

There are two conditions of x, x’s father, and x’s grandfather: whether they are in a straight line or not.

• If dir(x)$\ne$dir(y), we can just simply rotate x twice.
  
• If dir(x)$=$dir(y), if we rotate x’s father then rotate x, we will get this:
  
  Instead, if we rotate x twice, we will get this.
  
  The first one can keep the tree more balanced, especially when there is a long chain in the tree.

But actually, both methods meet some situations that will make the situation more or less balance.

I choose the first in the following code.
CODE:

void splay(int x,int to)
{ 
    while(tree[x].fa!=to)
    {
        int y=tree[x].fa;
        if(tree[y].fa==to) //Sometimes x only needs to be rotated once. 
            rotate(x);
        else if(dir(x)==dir(y))
            rotate(y),rotate(x);
        else
            rotate(x),rotate(x);
    }
    pushup(x);
    return;
}

3. build()
I prefer to use recursion to build the tree…

int build(int l,int r)
{
    if(l>r)
        return 0;
    int mid=(l+r)>>1;
    connect(build(l,mid-1),mid,0);
    connect(build(mid+1,r),mid,1);
    tree[mid].rev=0;
    pushup(mid);
    return mid; //The return value is the root. 
}

4. Two Basic Problems
$Important:Whenever$ $an$ $operation$ $about$ $nodes(which$ $means$ $asking$ $rank$ $is$ $excluded)$ $is$ $done,$ $splay$ $the$ $node.$

• P3391 (Luogu)

Overview: Several commands (l,r) which mean that the subsequence from l to r in the array is reversed are given. Print out the array you get after m commands.

/*
This function is for updating the reverse tag of the node. 
The main idea is that there is no need to reverse a section twice, so you can save lots of time by marking. (Similar to the lazy tag of the segment tree.)
*/
void pushdown(int x)
{
    if(tree[x].rev)
    {
        swap(tree[x].ch[0],tree[x].ch[1]); 
        tree[tree[x].ch[0]].rev^=1;
        tree[tree[x].ch[1]].rev^=1;
        tree[x].rev=0;
    }
    return;
}

int find(int x)
{
    int now=root;
    x--;
    pushdown(now);
    while(x!=tree[tree[now].ch[0]].tot)
    {
        if(tree[tree[now].ch[0]].tot<x)
            x-=tree[tree[now].ch[0]].tot+1,now=tree[now].ch[1];
        else
            now=tree[now].ch[0];
        pushdown(now);
        }
    return now;
}

PRINT:

void print(int now)
{
    if(!now)
        return;
    pushdown(now);
    print(tree[now].ch[0]);
    if(now!=1 && now!=n+2)
      cout<<now-1<<' ';
    print(tree[now].ch[1]);
    return; 
}

MAIN:

PosL=find(l);
splay(PosL,0);
PosR=find(r+2);
splay(PosR,root);
tree[tree[PosR].ch[0]].rev^=1;

（待填坑）有空我把splay的普通平衡树也实现一下放上来。有空再更一下splay的时间复杂度~~~