BZOJ 1269 文本编辑器editor（伸展树）

题意

https://www.lydsy.com/JudgeOnline/problem.php?id=1269

思路

伸展树（\(\text{splay}\)）功能比较齐全的模板，能较好的体现 \(\text{splay}\) 的功能，简单介绍一下 \(\text{splay}\)。

基本的概念和函数

\(\text{splay}\) 是平衡树的一种，能在均摊 \(\log n\) 的时间复杂度内完成很多序列操作（序列就是树的中序遍历），核心是以下两个函数。

rotate

首先是旋转函数，\(\text{rotate}(x)\) 表示旋转 \(x\) 节点到它父亲的位置，它的父亲变成它的孩子，在旋转函数的过程中，原树的中序遍历保持不变，代码如下：

void rotate(int x)
{
    int y=fa[x],z=fa[y],k=(x==ch[y][1]);
    if(z)ch[z][y==ch[z][1]]=x; fa[x]=z;
    ch[y][k]=ch[x][!k]; if(ch[x][!k])fa[ch[x][!k]]=y;
    ch[x][!k]=y,fa[y]=x;
    push_up(y),push_up(x);  //有时需要
}

网上有大量旋转函数过程图，这里不再解释。另外函数中的两个判断语句其实可以不用，零节点有儿子或父亲并不会造成错误，只是后面的 \(\text{LCT}\) 需要判断。

splay

然后是伸展函数，\(\text{splay}(x,w)\) 表示将 \(x\) 通过 \(\text{rotate}\) 函数上旋至成为 \(w\) 的儿子，特别的，当 \(w=0\) 时，表示将 \(x\) 上旋至根节点。

有一点特别注意，当节点 \(x\)，\(x\) 的父亲 \(y\) ，\(y\) 的父亲 \(z\) 三点共线，需要先转 \(y\) 再转 \(x\) ，否则转两次 \(x\) 。可以通过模拟一条链的旋转发现这种方法的优越性。

代码如下，可以写的很短：

void splay(int x,int w)
{
    while(fa[x]!=w)
    {
        int y=fa[x],z=fa[y];
        if(z!=w)(x==ch[y][1])==(y==ch[z][1])?rotate(y):rotate(x);
        rotate(x);
    }
    if(!w)rt=x;
}

注意在函数调用之前保证 \(x\) 以及 \(x\) 的祖先全部 \(\text{down}\) 完了。

基本的操作

构造

可以扔一个完美的 \(\text{splay}\) 上去，据说是对后面的操作在常数上有利。

void build(int &x,int f, int *arr,int l,int r)
{
    if(l>r)return;
    int mid=(l+r)>>1;
    x=++tot;
    ch[x][0]=ch[x][1]=0;
    fa[x]=f;
    pw[x]=arr[mid];
    sz[x]=1,rev[x]=0;   //在构造时清空会比较方便，如果有点权、标记的话要清空
    build(ch[x][0],x,arr,l,mid-1);
    build(ch[x][1],x,arr,mid+1,r);
    push_up(x);
}

插入

对于维护中序权值单调的平衡树，通过这种方式实现插入函数。

void insert(int val)
{
    int x=rt,y=0;
    while(x&&val!=pw[x])y=x,x=ch[x][val>pw[x]];
    if(!x)
    {
        x=++tot;
        ch[x][0]=ch[x][1]=0;
        fa[x]=y,ch[y][val>pw[y]]=x;
        sz[x]=cnt[x]=1;
        pw[x]=val;
    }
    else sz[x]++,cnt[x]++;
    splay(x,0);
}

前驱后继

同样的，对于一个中序单调的 \(\text{splay}\) ，可以通过查找的方法获得前驱后继，这也就是找第一个大于/小于（等于）一个数 \(v\) 的方法，即在 \(\text{splay}\) 上二分。

int get_lss(int val)
{
    int x=rt,y=0,tmp=-1,res=-1e9;
    while(x)
    {
        if(pw[x]<val&&chk_max(res,pw[x]))tmp=x;
        y=x,x=ch[x][val>pw[x]];
    }
    splay(y,0);
    return tmp;
}
int get_grt(int val)
{
    int x=rt,y=0,tmp=-1,res=1e9;
    while(x)
    {
        if(pw[x]>val&&chk_min(res,pw[x]))tmp=x;
        y=x,x=ch[x][val>=pw[x]];
    }
    splay(y,0);
    return tmp;
}

当然对于中序不一定单调，维护一个普通序列的 \(\text{splay}\) ，可以从结构上分析，利用旋转操作中序不变的性质。

int get_pre(int x)
{
    splay(x,0);
    if(!ch[x][0])return -1;
    x=ch[x][0];
    while(ch[x][1])x=ch[x][1];
    splay(x,0);
    return x;
}
int get_nxt(int x)
{
    splay(x,0);
    if(!ch[x][1])return -1;
    x=ch[x][1];
    while(ch[x][0])x=ch[x][0];
    splay(x,0);
    return x;
}

第K大值

与动点线段树写法类似，直接二分即可。

int get_Kth(int K)
{
    //K++;  因为有些题目需要加上极小值和极大值，为了下面调用的方便起见加了这一句话
    int x=rt;
    while(push_down(x),K!=sz[ch[x][0]]+1)
    {
        if(K<=sz[ch[x][0]])x=ch[x][0];
        else K-=sz[ch[x][0]]+1,x=ch[x][1];
    }
    splay(x,0);
    return x;
}

在这里说一下 \(\text{splay}\) 调用的时机，复杂度的证明我目前看不懂，但我知道由于 \(\text{splay}\) 是均摊 \(\log n\) ，所以只要是经过若干次循环迭代到的节点，都要上旋以防止复杂度堆积。

求一个点是第几大

void down_all(int x)
{
    if(!x)return;
    down_all(fa[x]);
    push_down(x);
}
int get_rank(int x)
{
//  down_all(x);        注意在自底向上操作一个点前，要保证标记传完
    splay(x,0);
    return sz[ch[x][0]]+1;
//  return sz[ch[x][0]];    同理，在有极小值时采用这种写法
}

区间操作

我们需要的就是“取出”一个区间，一般采取这样的方法：

l=get_Kth(l-1),r=get_Kth(r+1);
splay(l,0),splay(r,l);

这样之后，\(\text{ch}[r][0]\) 就是我们需要的区间了，区间打标记，求和，挪位什么的就很好实现了。

\(\text{splay}\) 也被叫做分裂树，它能实现区间的，挪位，这是它很显著的优势。

代码

#include<bits/stdc++.h>
#define FOR(i,x,y) for(int i=(x),i##END=(y);i<=i##END;++i)
#define DOR(i,x,y) for(int i=(x),i##END=(y);i>=i##END;--i)
template<typename T,typename _T>inline bool chk_min(T &x,const _T y){return y<x?x=y,1:0;}
template<typename T,typename _T>inline bool chk_max(T &x,const _T y){return x<y?x=y,1:0;}
typedef long long ll;
const int N=3e6+5;
struct Splay
{
    int ch[N][2],fa[N];char pw[N];
    int sz[N];bool rev[N];
    int rt,tot;
    int operator [](const int x){return pw[get_Kth(x)];}
    void init()
    {
        rt=tot=0;
        ch[0][0]=ch[0][1]=fa[0]=sz[0]=rev[0]=0;
        char str[2]={' ',' '};
        build(rt,0,str,0,1);
    }
    void reved(int x)
    {
        rev[x]^=1;
        std::swap(ch[x][0],ch[x][1]);
    }
    void push_up(int x){sz[x]=sz[ch[x][0]]+sz[ch[x][1]]+1;}
    void push_down(int x)
    {
        if(!rev[x])return;
        if(ch[x][0])reved(ch[x][0]);
        if(ch[x][1])reved(ch[x][1]);
        rev[x]=0;
    }
    void rotate(int x)
    {
        int y=fa[x],z=fa[y],k=(x==ch[y][1]);
        if(z)ch[z][y==ch[z][1]]=x; fa[x]=z;
        ch[y][k]=ch[x][!k]; if(ch[x][!k])fa[ch[x][!k]]=y;
        ch[x][!k]=y,fa[y]=x;
        push_up(y),push_up(x);
    }
    void splay(int x,int w)
    {
        while(fa[x]!=w)
        {
            int y=fa[x],z=fa[y];
            if(z!=w)(x==ch[y][1])==(y==ch[z][1])?rotate(y):rotate(x);
            rotate(x);
        }
        if(!w)rt=x;
    }
    void build(int &x,int f,char *arr,int l,int r)
    {
        if(l>r)return;
        int mid=(l+r)>>1;
        x=++tot;
        ch[x][0]=ch[x][1]=0;
        fa[x]=f;
        pw[x]=arr[mid];
        sz[x]=1,rev[x]=0;
        build(ch[x][0],x,arr,l,mid-1);
        build(ch[x][1],x,arr,mid+1,r);
        push_up(x);
    }
    int get_Kth(int K)
    {
        K++;
        int x=rt;
        while(push_down(x),K!=sz[ch[x][0]]+1)
        {
            if(K<=sz[ch[x][0]])x=ch[x][0];
            else K-=sz[ch[x][0]]+1,x=ch[x][1];
        }
        splay(x,0);
        return x;
    }
    void insert(int pos,char *str,int n)
    {
        int l=get_Kth(pos),r=get_Kth(pos+1);
        splay(l,0),splay(r,l);
        build(ch[r][0],r,str,0,n-1);
        splay(r,0);
    }
    void flip(int l,int r)
    {
        l=get_Kth(l-1),r=get_Kth(r+1);
        splay(l,0),splay(r,l);
        reved(ch[r][0]);
    }
    void erase(int l,int r)
    {
        l=get_Kth(l-1),r=get_Kth(r+1);
        splay(l,0),splay(r,l);
        ch[r][0]=0;
        splay(r,0);
    }
}SP;
int n,mouse;
char str[N];

int main()
{
    SP.init();
    mouse=0;
    scanf("%d",&n);
    while(n--)
    {
        int x;
        scanf("%s",str);
        if(str[0]=='M')
        {
            scanf("%d",&x);
            mouse=x;
        }
        else if(str[0]=='I')
        {
            scanf("%d",&x);getchar();
            FOR(i,0,x-1)str[i]=getchar();
            str[x]='\0';
            SP.insert(mouse,str,x);
        }
        else if(str[0]=='D')
        {
            scanf("%d",&x);
            SP.erase(mouse+1,mouse+x);
        }
        else if(str[0]=='R')
        {
            scanf("%d",&x);
            SP.flip(mouse+1,mouse+x);
        }
        else if(str[0]=='G')
            printf("%c\n",SP[mouse+1]);
        else if(str[0]=='P')mouse--;
        else if(str[0]=='N')mouse++;
    }
    return 0;
}

转载于:https://www.cnblogs.com/Paulliant/p/10359926.html