非常詳細的Splay筆記

Splay筆記

0.
第一次接觸是去年暑假一位巨佬學長介紹了這麼一種神奇的平衡樹，不過當時感覺沒怎麼完全弄懂。後來仔細想了一下個人感覺理解大有加深，這個數據結構確實非常優秀~~~傳到CSDN上來啦！
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)$\not=$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
$\color{red}{Important:Whenever}$ $\color{red}{an}$ $\color{red}{operation}$ $\color{red}{about}$ $\color{red}{nodes(which}$ $\color{red}{means}$ $\color{red}{asking}$ $\color{red}{rank}$ $\color{red}{is}$ $\color{red}{excluded)}$ $\color{red}{is}$ $\color{red}{done,}$ $\color{red}{splay}$ $\color{red}{the}$ $\color{red}{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的時間複雜度~~~