平衡树学习小记
总起
修炼了2天，终于差不多完成基础了，数据结构都是很灵活的，不仅是应用，而且写代码也是有很多值得思考的地方。而在平衡树中，旋转是核心的核心。
先总结一下吧。
先说明一些概念
键值，所谓的key，我一般用val表示，就是当前点存的值。
ind(ex)，引索，就是用平衡树要维护的东西，可能还用wei(ght)来表示。相当于普通序列中的下标。
虚拟节点：第n+1个点，放在所有点之前，让平衡树有头；第n+2个点，放在最后，让平衡树有尾。这两个点没有实际意义，用作连接。
siz(e)，以当前点为根的子树的点的个数，不包括虚拟点。
cnt，有时候不离散化要来统计相同key的点个数。
root或top，平衡树的根。
Treap
之前感觉splay有点难搞，所以先打一发treap。
treap的核心，就是每一个点的weight。它在保持搜索树同时，要维护weight，保持一个weight的小根堆。其中weight是随机生成的。（随机这种东西要记住啊！！！）
几个操作简介
1，旋转。只有单旋，很朴素，没什么好讲的；
2，插入一个点X。先像普通BST一样插入，然后当X成为了叶节点的时候，一步步把它像栈up上去，保持父亲的weight比儿子的大。
3，删除一个点X。其实有两种。1)把 X down到底下做成叶节点，直接删除，很简洁；2)把X up到顶分裂合并，这个比较麻烦。
4，分裂。即把一棵treap分成左右两边，其中满足BST的性质。这个后面splay再说。
5，合并。其实就是分裂反过来。
6，查找。可以利用size来查。也可以直接用BST的方式查。查找第K大，找元素都很方便。
优点是很明显的：十分容易调，超级简洁。很多都是递归完成，核心也很少。还能可持久化。
缺点：没有吧···
排序的应用代码
#includey])?0:1;
tr[y][(zy])?0:1]=t1;
return;
}
if (zx])
{
insert(tr[x][0],x,z);
if (wei[tr[x][0]]x]) rotate(tr[x][0]);
}
else
{
insert(tr[x][1],x,z);
if (wei[tr[x][1]]x]) rotate(tr[x][1]);
}
}
void dele(int y)
{
int x=top;
while (key[x]!=y)
{
if (yx])
x=tr[x][0];
else
x=tr[x][1];
}
if (cnt[x]==1)
while (tr[x][0]!=0||tr[x][1]!=0)
{
if (wei[tr[x][0]]tr[x][1]]) rotate(tr[x][0]);
else
rotate(tr[x][1]);
}
y=x;
cnt[x]--;
while (x)
{
update(x);
x=up[x];
}
if (!cnt[y])
{
tr[up[y]][pd(y)]=0;
key[y]=0;
wei[y]=0;
up[y]=0;
}
}
int find(int x)
{
int ret=0,y=top;
while (key[y]!=x)
{
if (xy]) y=tr[y][0];else
{
ret=ret+siz[y]-siz[tr[y][1]];
int kan=siz[tr[y][0]]+cnt[y];
y=tr[y][1];
}
}
ret+=siz[tr[y][0]]+cnt[y];
cnt[y]--;
return ret;
}
int main()
{
freopen("sort.in","r",stdin);
freopen("treap.out","w",stdout);
scanf("%d",&n);
wei[0]=mx+1;
fo(i,1,n) scanf("%d",a+i);
fo(i,1,n)
{
if (top==0)
{
top=1;
t1=1;
key[t1]=a[i];
wei[t1]=(ll)(a[i]+100)*pri%mo;
siz[t1]=1;
cnt[t1]++;
continue;
}
insert(top,0,a[i]);
dele(a[i]);
insert(top,0,a[i]);
}
fo(i,1,n)
{
pos=find(a[i]);
ans[pos]=a[i];
}
fo(i,1,n) printf("%d\n",ans[i]);
} 应用在排序容易检验各种操作的正确性，容易拍。在最后的求答案中，怎么样求答案都是行的。比如分离后又合并等。
treap让我逐步建立了对于平衡树的思维方式。
Splay
数据结构优美的特点在于函数化，只要函数正确，维护的代码是很可打的。而Splay很灵活，操作很多，需要用脑想，去简洁化，然后就可以写得又爽又快。
splay没有什么拘束，ind或者说weight的值不一定要刻意维护，自己想怎么玩弄它就怎么玩，想想就很爽！
Splay的核心：单旋转与双旋转
单旋转
不管是左儿子还是右儿子旋转上去，我们都可以直接用一段代码完成，很明了，不记得了就画个图，找找套路。
void rotate(int x)
{
int y=up[x],z=pd(x);//pd函数为判断节点X是它父亲的左儿子或者右儿子
down(y);//下传懒标记
down(x);//下传懒标记
up[x]=up[y];
if (up[y]) tr[up[y]][pd(y)]=x;
tr[y][z]=tr[x][1-z];
if (tr[y][z]) up[tr[y][z]]=y;
up[y]=x;
tr[x][1-z]=y;
update(y);//更新节点信息
update(x);//注意两个update的顺序
}双旋转
这是精华吧，网上的叙述很完备了，值得注意的是Zig-Zig时要先旋转父亲，再旋转儿子。
下面的splay函数，包括了双旋与单旋，而实质上都是单旋构成的。
void splay(int x,int y)
{
while (up[x]!=y)
{
if (up[up[x]]!=y)
if (pd(x)==pd(up[x])) rotate(up[x]);else rotate(x);
rotate(x);
}
if (!y) root=x;
}插话：维护序列
splay维护序列，实际上就是把序列下标作为BST的ind，然后就可以乱搞了。想一想：如果要让一颗子树只包含下标为l~r要怎么搞。
其他重要操作
这一部分要学好，我觉得要操作和题目配合着看，效果更好，但限于时间只能打点操作了。
1，合并x,y。
两颗splay合起来，保证x的所有元素的ind比y的大（注：有时候，ind的值不用记的，也不用刻意维护，看情况用），只需要让x进行“光头处理”，即让x的根节点（谁做根没关系）只有左儿子。
这之后x直接把y的根作为右儿子就行了，同时注意总根为x的根。
就算对y进行光头处理再类似地做也是一点问题都没有的。
2，分离
随便搞搞，看题目来。
3，找最值
我们类似于线段树一样，给每个点x都定义一个minium，或者maxinum，表示以x为根的子树，key值的最值。
4，玩弄序列时，在不维护index的情况下找原序列下标为K的元素
我们不是有siz吗？对于根的左边，ind即使没有记录，我们也知道左子树的所有点ind比根小，所以实际上已经是有序的了。细节比较难以表述，其实挺容易想懂，不写了~~~
5，不维护index，翻转序列
我们要把原序列中下标为l~r的元素下标全部翻转，即r变成l，r-1变为l+1····很简单，只需要把l~r搞在一棵子树里，然后对于每个点直接交换左右子树位置即可。当然了，为了保证时间复杂度，打懒标记，到时候碰到才下传。
6，区间修改和单点修改
7，····
感受
学了一会，就喜欢上了splay、treap，他们变化多端，splay可以搞LCT，treap可以可持久化，他们还都可以树套树···平时没事干，多多在脑海里splay一下，treap更新一下，会有收获。每次打的平衡树，都会根据实际情况变化，实在是有趣。
切题
JZOJ1149：又是排序，这次放splay
要记得每次操作都要SPLAY
#includetr[bef][0]=t1;else tr[bef][1]=t1;
return;
}
kan=x;
if (yx])
insert(tr[x][0],y,z,x);
else
insert(tr[x][1],y,z,x);
}
void splay(int x,int y)
{
while (up[x]!=y)
{
if (up[up[x]]!=y)
if (pd(x)==pd(up[x])) rotate(up[x]);
else
rotate(x);
rotate(x);
}
if (!y) root=x;
}
int getmin(int x)
{
if (!tr[x][0]) return x;
else return getmin(tr[x][0]);
}
int getmax(int x)
{
if (!tr[x][1]) return x;
else return getmax(tr[x][1]);
}
int merge(int x1,int x2)
{
up[x1]=0;
up[x2]=0;
if (!x1) return x2;
else if (!x2) return x1;
int l=getmax(x1);
splay(l,0);
tr[l][1]=x2;
up[x2]=l;
return l;
}
int main()
{
freopen("sort.in","r",stdin);
//freopen("splay.out","w",stdout);
scanf("%d",&n);
fo(i,1,n) scanf("%d",a+i);
fo(i,1,n)
{
if (!t1)
{
t1++;
key[t1]=a[i];
index[t1]=i;
root=t1;
continue;
}
insert(root,a[i],i,0);
splay(t1,0);
}
fo(i,1,n)
{
ans=getmin(root);
printf("%d\n",key[ans]);
splay(ans,0);
root=merge(tr[root][0],tr[root][1]);
}
} JZOJ1960 最大值2，区间修改，区间询问。
#includex]) x=tr[x][0];
else x=tr[x][1];
}
return x;
}
int main()
{
freopen("max2.in","r",stdin);
freopen("max2.out","w",stdout);
scanf("%d",&n);
last=n+1;
root=n+1;
fo(i,1,n)
{
scanf("%d",a+i);
up[i]=last;
tr[last][1]=i;
val[i]=a[i];
ind[i]=i;
last=i;
}
t1=n+2;
ind[n+1]=0;
ind[n+2]=n+1;
tr[n][1]=n+2;
mx[0]=val[0]=val[n+2]=val[n+1]=-inf;
up[n+2]=n;
x=n+2;
while (x)
{
mx[x]=max(mx[tr[x][1]],val[x]);
x=up[x];
}
splay(n+2,0);
scanf("%d",&m);
fo(i,1,m)
{
scanf("%d%d%d",&kase,&x,&y);
tmp=find(root,y+1);//pos==x? find ind which ==y+1
splay(tmp,0);
tmp=tr[tmp][0];
tp=find(tmp,x-1);
splay(tp,root);
if (kase==1)
{
scanf("%d",&z);
des[tr[tp][1]]=z;
down(tr[tp][1]);
}
else
printf("%d\n",mx[tr[tp][1]]);
}
} JZOJ3599 机械臂排序，涉及翻转
#includeint main()
{
freopen("mach.in","r",stdin);
freopen("sb1.out","w",stdout);
scanf("%d",&n);
last=n+1;
root=n+1;
fo(i,1,n) scanf("%d",a+i);
//离散化
fo(i,1,n)
{
b[i].a=a[i];
b[i].b=i;
}
sort(b+1,b+1+n,cmp);
fo(i,1,n)
a[b[i].b]=i;
fo(i,1,n)
{
up[i]=last;
val[i]=a[i];
tr[last][1]=i;
dep[i]=1;
last=i;
}
up[n+2]=n;
tr[n][1]=n+2;
mn[0]=val[0]=val[n+2]=val[n+1]=inf;
dep[n+2]=1;
x=n+2;
while (x)
{
update(x);
x=up[x];
}
splay(n+2,0);
fo(i,1,n)
{
splay(l=find(root,i-1),0);
tmp=getmin(tr[l][1]);//return的东西不对
if (iprintf("%d ",tmp+i-1);
splay(r=find(tr[l][1],tmp+1),root);
des[tr[r][0]]^=1;
down(tr[r][0]);
}
printf("%d",tmp+n-1);
} 题目不断更新···