splay区间翻转

原题P3391 【模板】文艺平衡树（Splay）

题目背景
这是一道经典的Splay模板题——文艺平衡树。

题目描述
您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：翻转一个区间，例如原有序序列是5    ，翻转区间是[,]的话，结果是5    

输入输出格式
输入格式：

第一行为n,m n表示初始序列有n个数，这个序列依次是(,,⋯n−,n) m表示翻转操作次数

接下来m行每行两个数 [l,r] 数据保证1≤l≤r≤n

输出格式：

输出一行n个数字，表示原始序列经过m次变换后的结果

输入输出样例
输入样例#： 复制

输出样例#： 复制

说明
n,m≤

查看题面

题解

这道题目要求支持区间翻转，这是splay的典型操作。

基本思想：

• 只要将一棵BST每一个节点的左右子树交换，就相当于翻转次树的中序遍历

实现方法：

1. 用节点中序遍历的序号表示当前节点的下标，用key存节点的序号，经过一系列操作后中序遍历即为所求

2. 每次翻转区间【L，R】时只要将排名为L-1的点splay到根，将排名R+1的点splay到根的右节点，根的右子树的左子树的中序遍历就是【L，R】

如何将一个点splay到指定位置？

只要引入y标记，当前节点的父亲为y时跳出，就可以将x刚好splay到y的儿子

inline void splay(int x,int y){
    for(int fa;(fa=f[x])!=y;rotate(x)){
        if(f[fa]!=y){
            rotate(get(fa)==get(x)?fa:x);
        }
    }
    if(y==){
        root=x;
    }
}

1.标记是在每一次访问到一个新的节点是就要pushdown的（改变树的结构会破坏标记区间，所以先一步下传标记）

inline void push_down(int x){
    if(x&&tag[x]){
        tag[son[x][]]^=;
        tag[son[x][]]^=;
        swap(son[x][],son[x][]);
        tag[x]=;
    }
}

2.区分一个节点的排名和这个节点的值：这个节点的排名是它是当前数组中的第几个，用左儿子的size+1表示；这个节点的值是题目中输入的数字，在本题中是1~N

3.增加数字为1和N+2的两个哨兵节点+INF和-INF，因此第i个节点的下标为i+1。

4.难道交换左右子树不会破坏BST的性质吗？这就是容易混淆的一点，我们的区间操作是根据下标翻转的，用数组实现时下标就是数组地址，子树交换时，只是存储内容的改变，下标位置（树的形状）只会在旋转时改变，保证BST性质。

5.此题要求一次性插入N个节点，所以可以用线段树建树的方法O(N)建树

int init(int l,int r,int fa){
    if(l>r){
        return ;
    }
    int mid=(l+r)>>,cur=++sz;
    key[cur]=val[mid];
    f[cur]=fa;
    son[cur][]=init(l,mid-,cur);
    son[cur][]=init(mid+,r,cur);
    upd(cur);
    return cur;
}

完整代码

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 const int INF=1e9+,MAXN=1e5+,MAXM=1e5+;
 int N,M,root,sz;
 int key[MAXN],val[MAXN],f[MAXN],son[MAXN][],tag[MAXN],siz[MAXN];
 inline void DEBUG(){
     printf("root=%d siz=%d\n",root,sz);
     for(int i=;i<=sz;i++){
         printf("(idx=%d\tkey=%d\tlc=%d\trc=%d)\n",i,key[i],son[i][],son[i][]);
     }
     puts("-------------------------------------------------------");
 }
 inline void upd(int x){
     if(x){
         siz[x]=;
         if(son[x][]){
             siz[x]+=siz[son[x][]];
         }
         if(son[x][]){
             siz[x]+=siz[son[x][]];
         }
     }
 }
 inline void push_down(int x){
     if(x&&tag[x]){
         tag[son[x][]]^=;
         tag[son[x][]]^=;
         swap(son[x][],son[x][]);
         tag[x]=;
     }
 }
 inline int get(int x){
     return x==son[f[x]][];
 }
 inline void rotate(int x){
     int fa=f[x],gf=f[fa],which=get(x);
     son[fa][which]=son[x][which^];
     f[son[fa][which]]=fa;
     son[x][which^]=fa;
     f[fa]=x;
     f[x]=gf;
     if(gf){
         son[gf][son[gf][]==fa]=x;
     }
     upd(fa);
     upd(x);
 }
 inline void splay(int x,int y){
     for(int fa;(fa=f[x])!=y;rotate(x)){
         if(f[fa]!=y){
             rotate(get(fa)==get(x)?fa:x);
         }
     }
     if(y==){
         root=x;
     }
 }
 int init(int l,int r,int fa){
     if(l>r){
         return ;
     }
     int mid=(l+r)>>,cur=++sz;
     key[cur]=val[mid];
     f[cur]=fa;
     son[cur][]=init(l,mid-,cur);
     son[cur][]=init(mid+,r,cur);
     upd(cur);
     return cur;
 }
 inline int findx(int x){//return the index
     int cur=root;
     while(){
         push_down(cur);
         if(son[cur][]&&x<=siz[son[cur][]]){
             cur=son[cur][];
         }else{
             x-=siz[son[cur][]]+;
             if(!x){
                 return cur;
             }
             cur=son[cur][];
         }
     }
 }
 void dfs(int x){
     push_down(x);
     if(son[x][]){
         dfs(son[x][]);
     }
     if(key[x]!=INF&&key[x]!=-INF){
         printf("%d ",key[x]);
     }
     if(son[x][]){
         dfs(son[x][]);
     }
 }
 int main(){
     scanf("%d%d",&N,&M);
     for(int i=;i<=N+;i++){
         val[i]=i-;
     }
     val[]=-INF;
     val[N+]=INF;
     root=init(,N+,);
     for(int i=;i<=M;i++){
         int ii,jj;
         scanf("%d%d",&ii,&jj);
         int l=findx(ii),r=findx(jj+);
         splay(l,);
         splay(r,l);
         tag[son[son[root][]][]]^=;
     }
     dfs(root);
     return ;
 }