fhq-treap简介

\(fhq-treap\)是个好东西啊！无旋转\(treap\)果然是好写，而且还是比较好理解的。

这种数据结构是由神犇fhq发明的。\(Think\ functional！\)

fhq神犇说，函数式编程的一大特点就是，不修改，只定义。普通的平衡树，无论是treap还是splay，都需要进行旋转来维护树的平衡性。

fhq神犇是通过可持久化线段树引入的。主席树其实就是一种函数式编程的产物。主席树中没有修改，只是每次新建了一条链（或者说新定义了一条链），而因为没有修改的优良性质，我们就可以使之与前面共用很大一部分，从而完成可持久化。

但是平衡树因为旋转操作需要记录父亲，所以它难以进行可持久化。毕竟，我们在rotate的过程中可是要大量修改节点之间的关系的。

需要记录父亲的数据结构一般都比较难可持久化。\(——RabbitHu\)

于是fhq神犇说，你为什么非要旋转呢？

下面就是\(fhq-treap\)最核心的两个操作——\(merge\)和\(split\)。

1、\(merge\)操作

\(merge\)就是把两棵平衡树合并成一棵。如何保持平衡呢？我们像普通的treap一样因为有随机的优先级，我们可以以这个为依据来判断如何合并。

对于\(merge(x,y)\)，我们合并的前提是以x为根的树A中节点权值小于以y为根的树B中节点权值。

对于\(merge(x,y)\)，如果x的优先级小于y，那么我们为了同时维护堆和二叉搜索树的性质，那么就要使y成为x的儿子，而且还需要在右子树。

反之，我们就要使x成为y的儿子，而且还要在左子树。

之后我们继续递归下去合并就可以了。如果其中有任意一个是空树就返回即可。

在实际应用的时候，我们往往是可以保证合并的前提的。因为要不然一开始是空树，要不然一开始会像建立splay一样建树，保证权值是像二叉搜索树一样的。

int merge(int x,int y)
{
	if(!x || !y) return x | y;
	pushdown(x),pushdown(y);
	if(t[x].rk < t[y].rk) {t[x].rc = merge(t[x].rc,y),pushup(x);return x;}
	else {t[y].lc = merge(x,t[y].lc),pushup(y);return y;}
}

2.\(split\)操作

与\(merge\)相对应，\(split\)就是把一棵平衡树分开，分裂成两棵。有两种分裂的方法，一种是按照权值分裂，一种按照子树大小分裂。

我们以按照权值分裂为例。对于$ split(u,k,x,y) $来说，我们要把一棵以u为根的平衡树分裂成以x，y为根的两棵平衡树，其中权值<=k的根为x，否则为y。首先我们判断当前的根的权值大小。如果<=k，那么就说明当前树的左子树应该全部以x为根，那么我们使x成为u，之后就剩下x的右子树需要进行分裂，那么我们使x成为x的右子树，y不变，继续向下分裂即可。注意这里要传址，因为x，y是一直在改变的。

否则的话，就说明当前的右子树应该全部以y为根。我们使y成为u，之后剩下y的左子树需要分裂，使y成为y的左子树，继续向下分裂即可。

按照子树大小也同理。

(权值)

void split(int u,int k,int &x,int &y)
{
    if(!u) x = y = 0;
    else
    {
        if(t[u].val <= k) x = u,split(t[u].ch[1],k,t[u].ch[1],y);
        else y = u,split(t[u].ch[0],k,x,t[u].ch[0]);
        pushup(u);
    }
}

(子树大小)

void splits(int u,int k,int &x,int &y)
{
	if(!u) {x = y = 0;return;}
	pushdown(u);
	if(t[t[u].lc].size >= k) y = u,splits(t[u].lc,k,x,t[u].lc);
	else x = u,splits(t[u].rc,k-t[t[u].lc].size-1,t[u].rc,y);
	pushup(u);
}

\(pushdown\)和\(pushup\)不是啥时候都要写的，看题的情况。

这就是最核心的操作。其他的什么查找第k大就二分一下就完事了。

那我们来练练手。普通平衡树和文艺平衡树。这个现在就很容易啦。每次操作先split提取出要操作的子树，处理完merge回去就行。注意区间翻转要时刻进行pushdown。

代码不贴了。

下一个话题就是进行可持久化。

传送门

感觉像是很简单的样子？不更改树的形态的话，那么我们只需要每次copy一下root，之后在当前的root上做各种操作就好了。

不过这是一个伪的可持久化，虽然在luogu上能得到96分……因为在\(merge\)和\(split\)的过程中，会使得你原来的版本发生变化。所以我们的解决办法是，每次新建立一个节点，新的版本在新建立的节点上进行操作。不过这样空间开销会变大一些。

其他的操作就没啥特殊的啦。

#include<bits/stdc++.h>
#define rep(i,a,n) for(int i = a;i <= n;i++)
#define per(i,n,a) for(int i = n;i >= a;i--)
#define enter putchar('\n')
#define I inline

using namespace std;
typedef long long ll;
const int M = 500005;
const int mod = 1e9+7;
const int INF = 2147483647;

I int read()
{
   int ans = 0,op = 1;char ch = getchar();
   while(ch < '0' || ch > '9') {if(ch == '-') op = -1;ch = getchar();}
   while(ch >= '0' && ch <= '9') ans = ans * 10 + ch - '0',ch = getchar();
   return ans * op;
}

struct tree
{
   int ch[2],fa,size,val,rk;
}t[M<<6];

int root[M],x,y,z,n,tim,op,w,tot,v;

I int newnode(int x)
{
   t[++tot].size = 1,t[tot].val = x,t[tot].rk = rand();
   return tot;
}

I void pushup(int x){t[x].size = t[t[x].ch[0]].size + t[t[x].ch[1]].size + 1;}

int merge(int x,int y)
{
   if(!x || !y) return x | y;
   if(t[x].rk < t[y].rk)
   {
      int p = ++tot;t[p] = t[x];
      t[p].ch[1] = merge(t[p].ch[1],y),pushup(p);
      return p;
   }
   else
   {
      int p = ++tot;t[p] = t[y];
      t[p].ch[0] = merge(x,t[p].ch[0]),pushup(p);
      return p;
   }
}

void split(int u,int v,int &x,int &y)
{
   if(!u) x = y = 0;
   else
   {
      if(t[u].val <= v) x = ++tot,t[x] = t[u],split(t[x].ch[1],v,t[x].ch[1],y),pushup(x);
      else y = ++tot,t[y] = t[u],split(t[y].ch[0],v,x,t[y].ch[0]),pushup(y);
   }
}

I int kth(int x,int k)
{
   while(1)
   {
      if(t[t[x].ch[0]].size >= k) x = t[x].ch[0];
      else if(k == t[t[x].ch[0]].size + 1) return x;
      else k -= (t[t[x].ch[0]].size + 1),x = t[x].ch[1];
   }
}

int main()
{
   srand(time(NULL));
   n = read();
   rep(i,1,n)
   {
      tim = read(),op = read(),v = read();
      root[i] = root[tim];
      if(op == 1) split(root[i],v,x,y),root[i] = merge(merge(x,newnode(v)),y);
      if(op == 2)
      {
     split(root[i],v,x,y),split(x,v-1,x,z);
     z = merge(t[z].ch[0],t[z].ch[1]);
     root[i] = merge(merge(x,z),y);
      }
      if(op == 3) split(root[i],v-1,x,y),printf("%d\n",t[x].size + 1),root[i] = merge(x,y);
      if(op == 4) printf("%d\n",t[kth(root[i],v)].val);
      if(op == 5)
      {
     split(root[i],v-1,x,y);
     if(t[x].size == 0) printf("%d\n",-INF);
     else printf("%d\n",t[kth(x,t[x].size)].val);
     root[i] = merge(x,y);
      }
      if(op == 6)
      {
     split(root[i],v,x,y);
     if(t[y].size == 0) printf("%d\n",INF);
     else printf("%d\n",t[kth(y,1)].val);
     root[i] = merge(x,y);
      }
   }
   return 0;
}

这个都有了，那么再支持一个区间翻转也不是很难。

传送门

这题就比较复杂一点，区间旋转的时候需要像做文艺平衡树那题时候一样翻转，注意需要时刻pushdown。每次在pushdown的时候，都需要生成一个你左右儿子的新版本，否则的话会因为交换而修改原来版本的情况。

说实话，跑的有点慢，而且比较不稳定。

// luogu-judger-enable-o2
#include<bits/stdc++.h>
#define rep(i,a,n) for(int i = a;i <= n;i++)
#define per(i,n,a) for(int i = n;i >= a;i--)
#define enter putchar('\n')
#define I inline

using namespace std;
typedef long long ll;
const int M = 500005;
const int mod = 1e9+7;
const int INF = 2147483647;

I ll read()
{
   ll ans = 0,op = 1;char ch = getchar();
   while(ch < '0' || ch > '9') {if(ch == '-') op = -1;ch = getchar();}
   while(ch >= '0' && ch <= '9') ans = ans * 10 + ch - '0',ch = getchar();
   return ans * op;
}

struct tree
{
   int ch[2],val,size,fa,rk,rev;
   ll sum;
}t[M<<6];

int root[M],n,m,x,y,z,p,v,op,tim,l,r,tot;
ll last;

I int newnode(int x)
{
   t[++tot].size = 1,t[tot].val = t[tot].sum = x,t[tot].rk = rand();
   return tot;
}

I int copy(int x)
{
   int p = newnode(0);
   t[p] = t[x];
   return p;
}

I void pushup(int x)
{
   t[x].size = t[t[x].ch[0]].size + t[t[x].ch[1]].size + 1;
   t[x].sum = t[t[x].ch[0]].sum + t[t[x].ch[1]].sum + t[x].val;
}

I void pushdown(int x)
{
   if(!t[x].rev) return;
   if(t[x].ch[0]) t[x].ch[0] = copy(t[x].ch[0]);      
   if(t[x].ch[1]) t[x].ch[1] = copy(t[x].ch[1]);
   swap(t[x].ch[0],t[x].ch[1]),t[x].rev = 0;
   if(t[x].ch[0]) t[t[x].ch[0]].rev ^= 1;
   if(t[x].ch[1]) t[t[x].ch[1]].rev ^= 1;
}

int merge(int x,int y)
{
   if(!x || !y) return x | y;
   pushdown(x),pushdown(y);
   if(t[x].rk < t[y].rk) {t[x].ch[1] = merge(t[x].ch[1],y),pushup(x);return x;}
   else {t[y].ch[0] = merge(x,t[y].ch[0]),pushup(y);return y;}
}

void splits(int u,int v,int &x,int &y)
{
   if(!u) x = y = 0;
   else
   {
      pushdown(u);
      if(t[t[u].ch[0]].size >= v) y = copy(u),splits(t[y].ch[0],v,x,t[y].ch[0]),pushup(y);
      else x = copy(u),splits(t[x].ch[1],v - t[t[u].ch[0]].size - 1,t[x].ch[1],y),pushup(x);
   }
}

I void rever(int k,int l,int r)
{
   int a,b,c,d;
   splits(root[k],r,a,b),splits(a,l-1,c,d);
   t[d].rev ^= 1;
   root[k] = merge(merge(c,d),b);
}

I void query(int k,int l,int r)
{
   int a,b,c,d;
   splits(root[k],r,a,b),splits(a,l-1,c,d);
   printf("%lld\n",t[d].sum),last = t[d].sum;
   root[k] = merge(merge(c,d),b);
}

int main()
{
   srand(time(NULL));
   n = read();
   rep(i,1,n)
   {
      tim = read(),op = read(),root[i] = root[tim];
      if(op == 1)
      {
    	p = read() ^ last,v = read() ^ last;
     	splits(root[i],p,x,y);
     	root[i] = merge(merge(x,newnode(v)),y);
      }
      if(op == 2)
      {
      	p = read() ^ last,splits(root[i],p,x,y),splits(x,p-1,x,z);
      	root[i] = merge(x,y);
      }
      if(op == 3) l = read() ^ last,r = read() ^ last,rever(i,l,r);
      if(op == 4) l = read() ^ last,r = read() ^ last,query(i,l,r);
   } 
   return 0;
}

\(fhq-treap\)的简介就先到这里吧。orz，这果然是神仙数据结构啊。