写了两周数据结构，感觉要死掉了，赶紧总结一下，要不都没学明白。
SPLAY专题：
例：NOI2005 维修数列
典型的SPLAY问题，而且综合了SPLAY常见的所有操作，特别适合新手入门学习（比如我这种蒟蒻）
题目要求很多，我们一步一步来分析
首先，区间翻转是SPLAY一个很基础的操作，我们以他为基础分析这个SPLAY
例：luogu文艺平衡树
题目：读入一个序列，进行多次区间翻转操作，请你输出操作后的序列
我们怎么处理呢？
首先要明确一点，就是SPLAY是可以当做区间树来使用的（就像线段树一样）
所以，我们首先把原来读进来的序列建起一个SPLAY，建树方法类似于线段树
void buildtree(int l,int r,int f)
{
int mid=(l+r)>>1;
if(l==r)
{
tree[l].val=a[l];
tree[l].huge=1;
tree[l].ttag=0;
tree[l].fa=f;
tree[l].lson=tree[l].rson=0;
}
if(l<mid)
{
buildtree(l,mid-1,mid);
}
if(r>mid)
{
buildtree(mid+1,r,mid);
}
tree[mid].val=a[mid];
tree[mid].fa=f;
tree[mid].ttag=0;
update(mid);
if(mid<f)
{
tree[f].lson=mid;
}else
{
tree[f].rson=mid;
}
}注意到其中有一个ttag，这是翻转区间的标记，暂时先不用关心
这样我们就建起了一个SPLAY
然后我们把SPLAY的根置成整个区间的中点即可
还有一个要点，就是SPLAY中一个节点既是序列中的一个位置，也是树中一个根节点，换言之，如果你建立了一棵SPLAY，根节点对应的是原序列中4位置，那么他的左子树就要维护1-3位置，右子树要维护5-7位置，而4位置交给根节点自己，不能放进子树中
这也是他与线段树少数的区别。
所以如果我们有一个序列1,2,3,4,5,6,7
建起的SPLAY大概会长这个样子
接下来，我们来尝试做一下区间翻转：
假设我要翻转区间[2,4]，我要怎么办呢？
现在我希望找到一棵子树，使得这棵子树正好对应了[2,4]这个区间，然后我们把这个区间整体打上标记就可以了
怎么找？
这才是SPLAY真正要解决的问题
最后我们得出了一个结论：假设我们要翻转区间[2,4]，那么我们首先把1转到SPLAY的根上（别忘了，这是一棵伸展树，是可以旋转的）
那么旋转规则和treap类似，最后大概长这样吧：
至于怎么转的，暂时还不必关心，一会就提到
接下来，我们把5节点旋转到根节点的右儿子处，长这样：
（原谅本蒟蒻的画图技术）
发现什么了吗？
当5旋转到右子节点以后，你所需要的区间[2,4]自然出现在了5的左子树上！
这样我们只对这棵树打一个标记就好
总结：如果我想修改区间[l,r],那么我只需将节点l-1转至SPLAY的根节点上，将节点r+1转至根节点的右儿子上，那么这个右儿子的左子树就是你想要的区间[l,r]！
至于证明，由于SPLAY本质是一个二叉搜索树，所以要满足搜索树的性质（这也是所有基于二叉搜索树变形出的数据结构所有旋转，伸展等等诡异操作的原理）
而搜索树的性质：左子树<根<右子树
那就好办啦，把要修改的区间前驱放到根上，这样整个区间一定在根的右子树内
再把区间的后继放到根的右子树上，这样整个区间一定在这个节点的左子树内
这样不就分出来这段区间了吗。
等等，这里面是不有点问题？
是啊，如果l=1呢？
这样的话，l-1就为0了，而在SPLAY里，找的到这样一个点吗？
似乎找不到诶
或者，如果r=n的话，那r+1就等于n+1了，好像同样不存在诶
那我们怎么玩？
一句话：插入两个空节点！
为什么呢？
假如我们将整个区间由[1,n]变为[2,n+1]，然后加入1和n+2两个空节点，这样不就可以实现上面所说的所有要求了吗？
这就很妙啦
于是，我们来解决一下最后这个问题：怎么旋转？
结论如下（这里使用双旋splay，常数小一些）
void rotate(int st,int &ed)
{
int ltyp;
int v1=tree[st].fa;
int v2=tree[v1].fa;
if(tree[v1].rson==st)
{
ltyp=1;
}else
{
ltyp=0;
}
if(v1==ed)
{
ed=st;
}else
{
if(tree[v2].lson==v1)
{
tree[v2].lson=st;
}else
{
tree[v2].rson=st;
}
}
if(ltyp)
{
tree[tree[st].lson].fa=v1;
tree[v1].fa=st;
tree[v1].rson=tree[st].lson;
tree[st].lson=v1;
tree[st].fa=v2;
}else
{
tree[tree[st].rson].fa=v1;
tree[v1].fa=st;
tree[v1].lson=tree[st].rson;
tree[st].rson=v1;
tree[st].fa=v2;
}
update(v1);
update(st);
}
void splay(int st,int &ed)
{
while(st!=ed)
{
int v1=tree[st].fa,v2=tree[v1].fa;
if(v1!=ed)
{
if((tree[v1].lson==st&&tree[v2].lson!=v1)||(tree[v1].rson==st&&tree[v2].rson!=v1))
{
rotate(st,ed);
}else
{
rotate(v1,ed);
}
}
rotate(st,ed);
}
}双旋，按类似treap的方法反复旋转即可
最后，每次操作的时候都需要下传标记，然后想输出的话对这棵树进行中序遍历即可
全代码（文艺平衡树）：
#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <queue>
#include <stack>
#define ls tree[rt].lson
#define rs tree[rt].rson
using namespace std;
struct SPLAY
{
int lson;
int rson;
int val;
int fa;
bool ttag;
int huge;
}tree[100005];
int a[100005];
int rot;
int n,m;
void update(int rt)
{
tree[rt].huge=tree[ls].huge+tree[rs].huge+1;
}
void pushdown(int rt)
{
if(tree[rt].ttag)
{
tree[rt].ttag=0;
tree[ls].ttag^=1;
tree[rs].ttag^=1;
swap(tree[ls].lson,tree[ls].rson);
swap(tree[rs].lson,tree[rs].rson);
}
}
void buildtree(int l,int r,int f)
{
int mid=(l+r)>>1;
if(l==r)
{
tree[l].val=a[l];
tree[l].huge=1;
tree[l].ttag=0;
tree[l].fa=f;
tree[l].lson=tree[l].rson=0;
}
if(l<mid)
{
buildtree(l,mid-1,mid);
}
if(r>mid)
{
buildtree(mid+1,r,mid);
}
tree[mid].val=a[mid];
tree[mid].fa=f;
tree[mid].ttag=0;
update(mid);
if(mid<f)
{
tree[f].lson=mid;
}else
{
tree[f].rson=mid;
}
}
int findf(int rt,int v)
{
pushdown(rt);
if(tree[ls].huge+1==v)
{
return rt;
}else if(tree[ls].huge>=v)
{
return findf(ls,v);
}else
{
return findf(rs,v-1-tree[ls].huge);
}
}
void rotate(int st,int &ed)
{
int ltyp;
int v1=tree[st].fa;
int v2=tree[v1].fa;
if(tree[v1].rson==st)
{
ltyp=1;
}else
{
ltyp=0;
}
if(v1==ed)
{
ed=st;
}else
{
if(tree[v2].lson==v1)
{
tree[v2].lson=st;
}else
{
tree[v2].rson=st;
}
}
if(ltyp)
{
tree[tree[st].lson].fa=v1;
tree[v1].fa=st;
tree[v1].rson=tree[st].lson;
tree[st].lson=v1;
tree[st].fa=v2;
}else
{
tree[tree[st].rson].fa=v1;
tree[v1].fa=st;
tree[v1].lson=tree[st].rson;
tree[st].rson=v1;
tree[st].fa=v2;
}
update(v1);
update(st);
}
void splay(int st,int &ed)
{
while(st!=ed)
{
int v1=tree[st].fa,v2=tree[v1].fa;
if(v1!=ed)
{
if((tree[v1].lson==st&&tree[v2].lson!=v1)||(tree[v1].rson==st&&tree[v2].rson!=v1))
{
rotate(st,ed);
}else
{
rotate(v1,ed);
}
}
rotate(st,ed);
}
}
int split(int st,int ed)
{
int v1=findf(rot,st-1);
int v2=findf(rot,ed+1);
splay(v1,rot);
splay(v2,tree[v1].rson);
return tree[v2].lson;
}
void reverse(int st,int ed)
{
int v1=split(st,ed);
tree[v1].ttag^=1;
swap(tree[v1].lson,tree[v1].rson);
update(tree[v1].fa);
update(tree[tree[v1].fa].fa);
}
void print(int rt)
{
if(!rt)
{
return;
}
pushdown(rt);
print(ls);
printf("%d ",tree[rt].val);
print(rs);
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
a[i+1]=i;
}
buildtree(1,n+2,0);
rot=(n+3)>>1;
for(int i=1;i<=m;i++)
{
int st,ed;
scanf("%d%d",&st,&ed);
reverse(st+1,ed+1);
}
int v1=split(2,n+1);
print(v1);
return 0;
}这样SPLAY的基础知识就完成了
剩下的留待下一篇更新