Splay之区间翻转问题

题目描述

给你 n 个数 分别为 1,2,3,4–n
然后有 m 个操作，每个操作对应一段区间，将区间的数进行翻转。
比如 1,2,3,4,5 这段序列
操作区间为 2-4
翻转完成后的序列为 1,4,3,2,5

输入格式

第一行分别输入 n,m
第2行到m+1行每行输入两个数 对应操作的区间

输出格式

输出最后翻转完成后的序列

数据范围

n,m<=100000

---

Splay的区间问题第一道！
说起来也有意思， 本来Splay的初衷是作为权值搜索树来用的，没想到最广泛的用途却变成了解决区间序列操作的问题。

---

想一下如何解决这个问题。

原理

其实翻转区间就是翻转左右的子节点。
假如我们把 l翻转到根节点上去 r+2翻转到 根节点的右节点上去
那么 l-r 这段区间就会集中在根节点右节点的左节点里面。
不懂的可以画下图
然后我们就可以将这棵子树的左右节点全部翻转过来啦。

优化

但是 这样会发现一个问题 。
假如我们先翻转了 2-4 这个区间
然后又翻转了 2-4 这个区间，前前后后操作了两次，但最后一点效果都没有，岂不是很亏？
于是引入lazy标记
我们只需在父节点上打标记，然后进行下放就可以了，如果进行了两次相反的翻转，lazy标记就会消失 ，这样就减少了翻转的次数！

建树

如果我们还像平常的Splay一样，一个一个节点insert插入建树，确实很慢。
想一下之前学过的数据结构里，哪一个跟这个比较相似？
线段树
所以我们可以像线段树建树一样对Splay进行建树。
其实在替罪羊数里，重新建树也是用的这样的方法。

输出

由二叉搜索树的性质可以知道，最后的序列就是中序遍历得到的序列。

需要注意的问题

这棵Splay不是权值搜索树，而是区间翻转，所以查询时的关键字不是权值，而是位置！
只是在这道题里，权值跟位置一样罢了！
如果翻转 1-n 怎么办？
我们可以建立两个哨兵节点（我也不知道谁起的这名字）
分别在 1位置和n+2位置 这样就可以解决上面的问题了
注意，输出时不要输出哨兵节点~
下面给出代码

#include 
#include 
#define il inline
#define lson l,mid-1,now
#define rson mid+1,r,now 
using namespace std;
const int maxm=1e6+1;
const int inf=1e8;
int size[maxm],val[maxm],rev[maxm],key[maxm];
int f[maxm],son[maxm][2];
int root,tot;
il void pushdown(int x)
{
    if(x&&rev[x])
    {
        rev[son[x][0]]^=1;
        rev[son[x][1]]^=1;
        swap(son[x][0],son[x][1]);
        rev[x]=0;
    }
}
il bool get(int x)
{
    return son[f[x]][1]==x;
}
il void update(int x)
{
    if(x)
    {
        size[x]=1;
        if(son[x][0]) size[x]+=size[son[x][0]];
        if(son[x][1]) size[x]+=size[son[x][1]];
    }
}
il void rorate(int x)
{
    int fa=f[x],ffa=f[fa],which=get(x);
    bool fx=get(fa);
    son[fa][which]=son[x][which^1]; 
    f[son[fa][which]]=fa;  
    son[x][which^1]=fa;
    f[fa]=x;  
    f[x]=ffa;

    if(ffa)  
     son[ffa][fx]=x; 
    update(fa),update(x);  
}
il void splay(int x,int who)
{
    for (int fa;(fa=f[x])!=who;rorate(x))
        if (f[fa]!=who)
            rorate(get(fa)==get(x)?fa:x);
    if (!who) root=x;
}
int build(int l,int r,int fa)
{
    if(l>r) return 0;
    int mid=(l+r)>>1;
    int now=++tot;
    key[now]=val[mid];
    f[now]=fa;
    son[now][0]=build(lson);
    son[now][1]=build(rson);
    update(now);
    return now;
}
inline int findx(int kth)
{
    int now=root;
    while(1)
    {
       pushdown(now);
       if(kth<=size[son[now][0]]) now=son[now][0];
       else
       {
         kth-=size[son[now][0]]+1;
         if(!kth) return now;
         now=son[now][1];
       }
    }
}
void print(int now)
{
    pushdown(now);
    if(son[now][0]) print(son[now][0]);
    if(key[now]!=inf&&key[now]!=-inf) printf("%d ",key[now]);
    if(son[now][1]) print(son[now][1]);
}
il int read()
{
    int x=0;
    char ch=0;
    while(ch<'0'||ch>'9') ch=getchar();
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x;
}
int main()
{
    int n,m;
    n=read(),m=read();
    val[1]=-inf,val[n+2]=inf;
    for(int i=2;i<=n+1;i++)
     val[i]=i-1;
    root=build(1,n+2,0);
    //printf("%d\n",findx(m));
    for(int i=1;i<=m;i++)
    {
        int l,r;
        l=read(),r=read();
        int lx=findx(l),rx=findx(r+2);
        splay(lx,0);
        splay(rx,lx);
        rev[son[son[root][1]][0]]^=1;
    }
    print(root);
    return 0;
}