Splay普及版

辣么，我要介绍我自学的\(Splay\)了，虽然跟大佬们讲得会有些重复，但是自认为把一些玄妙的东西点出来了\(qwq\)

\(0x01\) 引言

首先，我并没觉得\(Splay\)有多难……代码长的原因也就最多是因为不用指针太麻烦……就好像你链表不用指针而用数组模拟，在插入删除的时候就有你好受的了\(qnq\),更何况树形结构更为麻烦，在树上的操作也更加花样繁多。总之，麻烦。

但是\(Splay\)在我眼中却更像是一种可以放诸四海而皆可用的算法,不但可以有效替代二叉搜索树、\(AVL\)树等数据结构，也不会由于\(Treap\)的随机键值而靠脸拿分（其实大多数情况下，只要没有因为被大佬%而rp--，\(Treap\)也是不错的选择），并且时间复杂度也是很可观的。

那么无论怎样，在学习一种新的、我喜欢的东西之前，总是要送一句话勉励自己，并抨击那些认为这种高级数据结构没有什么学的必要的人：

\(\color{cyan}{A}\) \(\color{cyan}{person}\) \(\color{cyan}{who}\) \(\color{cyan}{is}\) \(\color{cyan}{regarded}\) \(\color{cyan}{as}\) \(\color{cyan}{a}\) \(\color{cyan}{loser}\) \(\color{cyan}{isn't}\) \(\color{cyan}{those}\) \(\color{cyan}{ordinarys}\) \(\color{cyan}{,but}\) \(\color{cyan}{the}\) \(\color{cyan}{satisfieds}\)

最怕你一生庸碌无为，却总是安慰自己平凡可贵

那么开始吧！

一.旋转是个什么东西？？？

旋转这个操作呢，在之前的数据结构中，可谓见所未见，闻所未闻（瞎扯淡\(ing\)）。那么我们就先从旋转开始研究吧\(qwq\)！

由于是建立在一株二叉搜索树上的，所以当时是一条链时，旋转并不会影响树的结构\(qwqqq\)。

于是，二叉搜索树的旋转，完！

---

诶，骗你的啦，怎么可能完，你要知道每个节点可都是还有子节点的，如果直接旋转的话，就会出现一个节点有三个子节点的情况\(emmmmmm\)这可不是我们想看到的，因为瞬间你的一棵\(BT\)就毁灭了\(qwqqqq\)。

那么其实为了满足\(BST\)的特性,我们在上面这个图里可以看到如下内容：

根据点权来列不等式：

\(Y>X,B>X,\)如果\(Y<B,\)那么显然B不会跑到左子树去，所以得出结论:$$Y>B$$

所以我们可以发现，对于旋转时子节点的子树，我们完全可以将这个多余的子树转移到它原来的父节点上即可。

那么这个地方我们就得出一个宝贵的规律来：

我们定义一个结点与他父亲的关系是\(x\),那么在旋转时,他的父亲成为了他的\(!x\)儿子,并且那个上文中所说的“多余结点”，同时也是当前节点的\(!x\)儿子，但在旋转之后需要成为当前节点的“前”父节点的\(x\)儿子。

诶，其实这是找规律啦，但是也从另一个方面揭示了二叉搜索树的的某些本质\(qwqqq\)

\(Talk\) \(is\) \(\color{silver}{cheap}\) \(,show\) \(you\) \(the\) \(\color{silver}{code}\):

inline void update(int x){
	if(x){
		sub_size[x]=cnt[x];
		if(sons[x][1])sub_size[x]+=sub_size[sons[x][1]];
	    if(sons[x][0])sub_size[x]+=sub_size[sons[x][0]];
	}
	return ;
}
inline bool get_which(int x){
	return sons[f[x]][1]==x;
}
inline void rotate(int x){
	int father=f[x],g_father=f[father];
	bool which_son=get_which(x);//当前节点的关系
	sons[father][which_son]=sons[x][which_son^1];
	f[sons[father][which_son]]=father;
	sons[x][which_son^1]=father;
	f[father]=x;
	f[x]=g_father;
	if(g_father){
		sons[g_father][get_which(father)]=x;
	}
	update(x);
	update(father);
}

\(son\)表示每个节点的左右儿子，\(f\)表示每个节点的父亲\(sub\_size[i]\)表示以\(i\)为根的子树的大小。

诶，为什么要记录子树大小啊？

\(qwqqq\)是为了方便执行之后的\(zz\)操作啊

那么接下来我们看\(Splay\)操作，其实这个操作十分地简单，不过是拼命地向上旋转至根节点而已，但在这其中还有些地方值得注意：

\(\mathcal{1.}\)如果爷爷节点、父节点与自己不共线，那么就是这样

这时实际上并不会怎样……你就不断旋转就行了\(qwq\)

\(\mathcal{2.}\)如果三个节点共线的话，那么就先要旋转父节点，因为如果先旋转子节点的话，我们就会发现原来华丽的一条链的结构被破坏，接下来的一系列操作即会导致这棵树失衡，所以应该先旋转父节点，再旋转子节点\(qwq\)

╮(￣▽￣")╭虽然我不是很想做效果图，但是为了你们我忍了（逃

那么接下来是当三个点共线时的两种处理方式的不同结果：

\(emmmm\)实质上就是说，我们在链很长的时候，每次执行先旋父节点再旋当前节点的操作，一次总操作之后，这条链的深度会减半。

\(Talk\) \(is\) \(\color{silver}{cheap}\) \(,show\) \(you\) \(the\) \(\color{silver}{code}\):

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

诶，上图画的好像不是很浅显，因为节点数太少了\(qnq\),但是无论如何，本蒟蒻用机房的\(XP\)画图做图很难受的\(QAQ\)

---

---

那么接下来……那些二叉搜索树的插入删除操作我就不赘述了，因为本身二叉搜索树就可以支持找前驱后继、找排名找数，所以只需要注意以下两点：

1.每次进行有关点的操作时都要\(Splay\)一次，因为要维护树的随机性

2.注意第一条中的“有关点”，比如当给出排名找数的时候，由于其实跟这个点没什么关系，所以不用\(Splay\).

\(Show\) \(The\) \(Whole\) \(Code\)：

// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
using namespace std;
#define MAXN 1000000
int f[MAXN],cnt[MAXN],value[MAXN],sons[MAXN][2],sub_size[MAXN],whole_size,root;
inline int qread(){
    int res=0,k=1;
    char c=getchar();
    while(!isdigit(c)){
        if(c=='-')k=-1;
        c=getchar();
    }
    while(isdigit(c)){
        res=(res<<1)+(res<<3)+c-48;
        c=getchar();
    }
    return res*k;
}
inline void S_Clear(int x){
    sons[x][0]=sons[x][1]=f[x]=sub_size[x]=cnt[x]=value[x]=0;
}
inline bool get_which(int x){
    return sons[f[x]][1]==x;
}
inline void update(int x){
    if (x){
        sub_size[x]=cnt[x];
        if (sons[x][0]) sub_size[x]+=sub_size[sons[x][0]];
        if (sons[x][1]) sub_size[x]+=sub_size[sons[x][1]];
    }
    return ;
}
inline void rotate(int x){
    int father=f[x],g_father=f[father],which_son=get_which(x);
    sons[father][which_son]=sons[x][which_son^1];
    f[sons[father][which_son]]=father;
    sons[x][which_son^1]=father;
    f[father]=x;
    f[x]=g_father;
    if(g_father){
        sons[g_father][sons[g_father][1]==father]=x;
    }
    update(father);
    update(x);
}
inline void splay(int x){
    for (int fa;fa=f[x];rotate(x))
      if (f[fa])
        rotate((get_which(x)==get_which(fa))?fa:x);
    root=x;
}
inline void insert(int x){
    if(!root){
        whole_size++;
        sons[whole_size][0]=sons[whole_size][1]=f[whole_size]=0;
        root=whole_size;
        sub_size[whole_size]=cnt[whole_size]++;
        value[whole_size]=x;
        return ;
    }
    int now=root,fa=0;
    while(1){
        if(x==value[now]){
            cnt[now]++;
            update(now);
            update(fa);
            splay(now);
            break;
        }
        fa=now;
        now=sons[now][value[now]<x];
        if(!now){
            whole_size++;
            sons[whole_size][0]=sons[whole_size][1]=0;
            f[whole_size]=fa;
            sub_size[whole_size]=cnt[whole_size]=1;
            sons[fa][value[fa]<x]=whole_size;
            value[whole_size]=x;
            update(fa);
            splay(whole_size);
            break;
        }
    }

}
inline int find_num(int x){
    int now=root;
    while(1){
        if(sons[now][0]&&x<=sub_size[sons[now][0]])
        now=sons[now][0];
        else {
            int temp=(sons[now][0]?sub_size[sons[now][0]]:0)+cnt[now];
            if(x<=temp)return value[now];
            x-=temp;
            now=sons[now][1];
        }
    }
}

inline int find_rank(int x){
      int now=root,ans=0;
    while(1){
        if (x<value[now])
          now=sons[now][0];
        else{
            ans+=(sons[now][0]?sub_size[sons[now][0]]:0);
            if (x==value[now]){
                splay(now); return ans+1;
            }
            ans+=cnt[now];
            now=sons[now][1];
        }
    }
}
inline int find_pre(){
    int now=sons[root][0];
    while(sons[now][1])now=sons[now][1];
    return now;
}
inline int find_suffix(){
    int now=sons[root][1];
    while(sons[now][0])now=sons[now][0];
    return now;
}
inline void my_delete(int x){
    int hhh=find_rank(x);
    if (cnt[root]>1){
    cnt[root]--;
    update(root);
    return;
    }
    if (!sons[root][0]&&!sons[root][1]) {
    S_Clear(root);
    root=0;
    return;
    }
    if (!sons[root][0]){
        int old_root=root;
        root=sons[root][1];
        f[root]=0;
        S_Clear(old_root);
        return;
    }  

    else if (!sons[root][1]){
        int old_root=root;
        root=sons[root][0];
        f[root]=0;
        S_Clear(old_root);
        return;
    }
    int left_max=find_pre(),old_root=root;
    splay(left_max);
    sons[root][1]=sons[old_root][1];
    f[sons[old_root][1]]=root;
    S_Clear(old_root);
    update(root);
}

int main(){
    int m,num,be_dealt;
    cin>>m;
    for(int i=1;i<=m;i++){
       num=qread();
       be_dealt=qread();
        switch(num)
        {
            case 1:insert(be_dealt);break;
            case 2:my_delete(be_dealt);break;
            case 3:printf("%d\n",find_rank(be_dealt));break;
            case 4:printf("%d\n",find_num(be_dealt));break;
            case 5:insert(be_dealt);printf("%d\n",value[find_pre()]);my_delete(be_dealt);break;
            case 6:insert(be_dealt);printf("%d\n",value[find_suffix()]);my_delete(be_dealt);break;
        }
    }
    return 0;
}

\(0x02\) \(Splay\)的渐进难度：

嗯呐……我发现本蒟做这种题总会被卡……并且总是被一些奇奇怪怪的东西卡死……呃不是算法，是打代码时不细心，导致调试了好长时间\(ORZ\).

那么，这道题的题面戳这里

那么对于区间反转这种操作，我们由于原数列的顺序已经给定，所以不能按照权值排序，所以选择按照点的编号建立一棵二叉搜索树。

诶，所以啊，不用一个个\(insert\)编号，我们只需要进行一下递归建树即可\(qwq\)——建树可以仿照线段树的建树\(qwq\)

那么就类似这样：

struct Splay_tree{
	int f,sub_size,cnt,value,tag;
	int son[2];
}s[MAXN];
inline void update(int x){
	if(x){
	s[x].sub_size=s[x].cnt;
	if(s[x].son[0])s[x].sub_size+=s[s[x].son[0]].sub_size;
    if(s[x].son[1])s[x].sub_size+=s[s[x].son[1]].sub_size;
	}
}
int build_tree(int l, int r, int fa) {
        if(l > r) { return 0; }
        int mid = (l + r) >> 1;
        int now = ++ wz;
        s[now].f=fa;
	    s[now].son[0]=s[now].son[1]=0;
		s[now].cnt++;
    	s[now].value=original[mid];
		s[now].sub_size++;
        s[now].son[0] = build_tree(l, mid - 1, now);
        s[now].son[1] = build_tree(mid + 1, r, now);
        update(now);
        return now;
}

\(emmmm\)码风还算是中规中矩吧\(qwq\)

那么我们现在已经有一棵编号树了(并且由于递归建树，一开始是平衡的)，我们要对它进行区间翻转操作。那么实际上我们可以发现，在反转区间\([l\)~\(r]\)的时候，我们可以考虑利用\(Splay\)的性质，将\(l-1\)翻转至根节点，再将\(r+1\)翻转至根节点的幼儿子，类似这样：

\(emmm\)本蒟蒻用英文作图只是因为会使风格更简约\(qwq\)

但在这里还是需要注意，我们为了方便，在\(1\)号节点之前和\(n\)号节点之后又加了两个节点并赋值为\(-INF\)和\(INF\)，作为虚点，既满足二叉搜索树的性质，又可以让我们在翻转\(1\)~\(n\)时不会\(GG\)

那么实际上，在我们把当前区间确定下来之后，我们就要开始进行反转操作。而对于反转操作，我们可以不断替换子节点的左右子树达到此目的。

比如对于\(1\)~\(5\)这个序列，我们反转\(2~4\)这个区间，过程就是这样：

首先建树，在这里用一个可行的树来举个栗子：

那么实际上我们如果反转\(2~4\)那么我们需要先将\(1\)和\(5\)旋转上去，类似这样：

实际上我们翻转两个子树就相当于反转\(2\)~\(4\) \(qwq\)

但在这个地方我们可以考虑打个标记，标记的存在就只在于记录现在对于当前节点应不应该翻转两个子树。

\(\color{gold}{Talk}\) \(is\) \(\color{silver}{cheap}\) \(,\color{gold}{show}\) \(you\) \(the\) \(\color{silver}{code}\):

inline void pushdown(int x){
    if(x&&s[x].tag){
    	s[s[x].son[1]].tag^=1;
    	s[s[x].son[0]].tag^=1;
    	swap(s[x].son[1],s[x].son[0]);
    	s[x].tag=0;
    }
}
inline int find(int x){
	int now=root;
	while(1)
	{
	    pushdown(now);
		if(x<=s[s[now].son[0]].sub_size){
			now=s[now].son[0];
		}
		else  {
		x-=s[s[now].son[0] ].sub_size + 1;
	    if(!x)return now;
	    now=s[now].son[1];
		}
	}
}
inline void reverse(int x,int y){
	int l=x-1,r=y+1;
	l=find(l),r=find(r);
	splay(l,0);
	splay(r,l);
	int pos=s[root].son[1];
	pos=s[pos].son[0];
	s[pos].tag^=1;//标记最初打在操作区间的根节点上
}

然后还有些需要注意的，注释了\(qwq\)

#include<iostream>
using namespace std;
#define MAXN 1000007
#define INF 100000089
struct Splay_tree{
	int f,sub_size,cnt,value,tag;
	int son[2];
}s[MAXN];
int original[MAXN],root,wz;
inline bool which(int x){
	return x==s[s[x].f].son[1];
}
inline void update(int x){
	if(x){
	s[x].sub_size=s[x].cnt;
	if(s[x].son[0])s[x].sub_size+=s[s[x].son[0]].sub_size;
    if(s[x].son[1])s[x].sub_size+=s[s[x].son[1]].sub_size;
	}
}
inline void pushdown(int x){
    if(x&&s[x].tag){
    	s[s[x].son[1]].tag^=1;
    	s[s[x].son[0]].tag^=1;
    	swap(s[x].son[1],s[x].son[0]);
    	s[x].tag=0;
    }
}
inline void rotate(int x){
	int fnow=s[x].f,ffnow=s[fnow].f;
	pushdown(x),pushdown(fnow);
	bool w=which(x);
	s[fnow].son[w]=s[x].son[w^1];
	s[s[fnow].son[w]].f=fnow;
	s[fnow].f=x;
	s[x].f=ffnow;
	s[x].son[w^1]=fnow;
	if(ffnow){
		s[ffnow].son[s[ffnow].son[1]==fnow]=x;
	}
	update(fnow);
}
inline void splay(int x,int goal){
	for(int qwq;(qwq=s[x].f)!=goal;rotate(x)){
		if(s[qwq].f!=goal){//这个地方特别重要，原因是需要判断的是当前的父亲有没有到目标节点，而如果把“qwq”改成“x”……就会炸
			rotate(which(x)==which(qwq)?qwq:x);
		}
	}
	if(goal==0){
		root=x;
	}
}

int build_tree(int l, int r, int fa) {
        if(l > r) { return 0; }
        int mid = (l + r) >> 1;
        int now = ++ wz;
        s[now].f=fa;
	    s[now].son[0]=s[now].son[1]=0;
		s[now].cnt++;
    	s[now].value=original[mid];
		s[now].sub_size++;
        s[now].son[0] = build_tree(l, mid - 1, now);
        s[now].son[1] = build_tree(mid + 1, r, now);
        update(now);
        return now;
}
inline int find(int x){
	int now=root;
	while(1)
	{
	    pushdown(now);
		if(x<=s[s[now].son[0]].sub_size){
			now=s[now].son[0];
		}
		else  {
		x-=s[s[now].son[0] ].sub_size + 1;
	    if(!x)return now;
	    now=s[now].son[1];
		}
	}
}
inline void reverse(int x,int y){
	int l=x-1,r=y+1;
	l=find(l),r=find(r);
	splay(l,0);
	splay(r,l);
	int pos=s[root].son[1];
	pos=s[pos].son[0];
	s[pos].tag^=1;
}
inline void dfs(int now){
	pushdown(now);
	if(s[now].son[0])dfs(s[now].son[0]);
	if(s[now].value!=-INF&&s[now].value!=INF){
		cout<<s[now].value<<" ";
	}
	if(s[now].son[1])dfs(s[now].son[1]);
}
int main(){
	int n,m,x,y;
	cin>>n>>m;
	original[1]=-INF,original[n+2]=INF;
	for(int i=1;i<=n;i++){
		original[i+1]=i;
	}
	root=build_tree(1,n+2,0);//有一个良好的定义变量习惯很重要……重复定义同一个变量（比如全局的和局部的同名）那么就会发生覆盖。
	for(int i=1;i<=m;i++){
		cin>>x>>y;
		reverse(x+1,y+1);
	}
	dfs(root);
}

最后来几道例题：

戳这里

这个题算是平衡树系列的一个进阶版本了吧\(qwq\).

好吧我承认，这个题我一开始做的时候已经想出了大约\(60\)%的样子，但是最后还是偷偷地瞅了眼题解，发现似乎很有道理，然后\(A\)了\(emmmm\).

那么好像很显然，我们坑定不能一个一个地修改，区间修改由于每次都是\(1\)~\(n\)，所以并没有什么很大的意义。所以我们可以考虑引入一个标记，每次\(A\)就$$delta+=num$$每次\(I\)就$$insert(num-delta)$$，询问时就$$cout<<query+delta$$,再加上几个判断是不是非法操作。

\(emmmmm\)好像海星，到这一步大约已经可以够得着\(NOIP\)的思维难度了。然而这是一道省选题，所以这么搞还是捕星，因为删除操作和询问离职人员好像很难搞。

那么，在这里我们考虑将\(-INF\)和\(INF\)在一开始就插入平衡树里。每次\(insert\)操作\(tot++\),最后只需要用$$tot-(find_rank(INF)-2)$$就可以算出离职人数。

那么只剩下最后一个问题了——我们该怎么删除呢？这里就需要用到一个二叉搜索树里很精妙的操作了——删除根的子树。我们可以在执行\(S\)操作时先\(delta-=num\)，然后将\(-INF\)旋转到根节点，将\(minn-delta\)旋转到根节点的右儿子，然后删除根节点的右子树的左子树即可。

诶这个操作很熟悉啊，不也是区间翻转时的操作吗？

诶怎么旋转\(minn-delta\)啊？

我们可以很简单地插入删除，这很简单，但是为什么要以\(minn-delta\)作为所删除的单调区间的上界？这个地方你可以稍微意会一下……因为我们插入的是\(num-delta\)啊!

嗯，我还是太弱了。

\(\color{red}{Code}:\)

#include<iostream>
#include<cstdio>
using namespace std;
#define MAXN 1000000
#define INF 283653129
int f[MAXN],cnt[MAXN],value[MAXN],sons[MAXN][2],sub_size[MAXN],whole_size,root;
inline int qread(){
    int res=0,k=1;
    char c=getchar();
    while(!isdigit(c)){
        if(c=='-')k=-1;
        c=getchar();
    }
    while(isdigit(c)){
        res=(res<<1)+(res<<3)+c-48;
        c=getchar();
    }
    return res*k;
}
inline void S_Clear(int x){
    sons[x][0]=sons[x][1]=f[x]=sub_size[x]=cnt[x]=value[x]=0;
}
inline bool get_which(int x){
    return sons[f[x]][1]==x;
}
inline void update(int x){
    if (x){
        sub_size[x]=cnt[x];
        if (sons[x][0]) sub_size[x]+=sub_size[sons[x][0]];
        if (sons[x][1]) sub_size[x]+=sub_size[sons[x][1]];
    }
    return ;
}
inline void rotate(int x){
    int father=f[x],g_father=f[father],which_son=get_which(x);
    sons[father][which_son]=sons[x][which_son^1];
    f[sons[father][which_son]]=father;
    sons[x][which_son^1]=father;
    f[father]=x;
    f[x]=g_father;
    if(g_father){
        sons[g_father][sons[g_father][1]==father]=x;
    }
    update(father);
    update(x);
}
inline void splay(int x,int goal){
    for(int qwq;(qwq=f[x])!=goal;rotate(x)){
        if(f[qwq]!=goal){
            rotate(get_which(x)==get_which(qwq)?qwq:x);
        }
    }
    if(!goal){
        root=x;
    }
}
inline void insert(int x){
    if(!root){
        whole_size++;
        sons[whole_size][0]=sons[whole_size][1]=f[whole_size]=0;
        root=whole_size;
        sub_size[whole_size]=cnt[whole_size]++;
        value[whole_size]=x;
        return ;
    }
    int now=root,fa=0;
    while(1){
        if(x==value[now]){
            cnt[now]++;
            update(now);
            update(fa);
            splay(now,0);
            break;
        }
        fa=now;
        now=sons[now][value[now]<x];
        if(!now){
            whole_size++;
            sons[whole_size][0]=sons[whole_size][1]=0;
            f[whole_size]=fa;
            sub_size[whole_size]=cnt[whole_size]=1;
            sons[fa][value[fa]<x]=whole_size;
            value[whole_size]=x;
            update(fa);
            splay(whole_size,0);
            break;
        }
    }

}
inline int find_num(int x){
    int now=root;
    while(1){
        if(sons[now][0]&&x<=sub_size[sons[now][0]])
        now=sons[now][0];
        else {
            int temp=(sons[now][0]?sub_size[sons[now][0]]:0)+cnt[now];
            if(x<=temp)return value[now];
            x-=temp;
            now=sons[now][1];
        }
    }
}
inline int find_ID(int x){
	int now=root;
	while(1){
		if(x==value[now]){
			return now;
		}
		else now=sons[now][value[now]<x];
	}
}
inline int find_rank(int x){
      int now=root,ans=0;
    while(1){
        if (x<value[now])
          now=sons[now][0];
        else{
            ans+=(sons[now][0]?sub_size[sons[now][0]]:0);
            if (x==value[now]){
                splay(now,0); return ans+1;
            }
            ans+=cnt[now];
            now=sons[now][1];
        }
    }
}
inline int find_pre(){
    int now=sons[root][0];
    while(sons[now][1])now=sons[now][1];
    return now;
}
inline int find_suffix(){
    int now=sons[root][1];
    while(sons[now][0])now=sons[now][0];
    return now;
}
inline void my_delete(int x){
    int hhh=find_rank(x);
    if (cnt[root]>1){
    cnt[root]--;
    update(root);
    return;
    }
    if (!sons[root][0]&&!sons[root][1]) {
    S_Clear(root);
    root=0;
    return;
    }
    if (!sons[root][0]){
        int old_root=root;
        root=sons[root][1];
        f[root]=0;
        S_Clear(old_root);
        return;
    }  

    else if (!sons[root][1]){
        int old_root=root;
        root=sons[root][0];
        f[root]=0;
        S_Clear(old_root);
        return;
    }
    int left_max=find_pre(),old_root=root;
    splay(left_max,0);
    sons[root][1]=sons[old_root][1];
    f[sons[old_root][1]]=root;
    S_Clear(old_root);
    update(root);
}
int main(){
    int m,num,minn;
    char a;
    cin>>m>>minn;
    insert(-INF);
	insert(INF);
	int delta=0,sumtot=0;
    for(int i=1;i<=m;i++){
    	cin>>a>>num;
    	switch(a){
    		case 'I' :{
    			if(num<minn)break;
    			insert(num-delta);
    			sumtot++;
    			break;
    		}
    		case 'A':{
    			delta+=num;
    			break;
    		}
    		case 'S':{
    			delta-=num;
    			insert(minn-delta);
    			int a=find_ID(-INF),b=find_ID(minn-delta);
				splay(a,0);
    			splay(b,a);
    			sons[sons[root][1]][0]=0;
    			my_delete(minn-delta);
    			break;
    		}
    		case 'F':{
    			int sumnow=find_rank(INF)-2;
    			if(sumnow<num){
    			cout<<-1<<endl;
				break;
    	  		}
				int  res=find_num(sumnow+2-num);
    			cout<<res+delta<<endl;
    			break;
    		}
    	}
    }
    int sumnow=find_rank(INF)-2;
    cout<<sumtot-sumnow;
	return 0;
}

代码好长啊……足足写了5.04K