可持久化文艺平衡树

您需要写一种数据结构，来维护一个序列，其中需要提供以下操作（对于各个以往的历史版本）：

  1. 在第 pp 个数后插入数 xx 。
  2. 删除第 pp 个数。
  3. 翻转区间 [l,r][l,r]，例如原序列是 {5,4,3,2,1}{5,4,3,2,1}，翻转区间 [2,4][2,4] 后，结果是 {5,2,3,4,1}{5,2,3,4,1}。
  4. 查询区间 [l,r][l,r] 中所有数的和。

和原本平衡树不同的一点是，每一次的任何操作都是基于某一个历史版本，同时生成一个新的版本（操作 44 即保持原版本无变化），新版本即编号为此次操作的序号。

本题强制在线。

分析

函数式Treap实现。

时空复杂度\(O(n \log n)\)

  1. // luogu-judger-enable-o2
  2. typedef long long ll;
  4. co int N=2e5+7;
  5. int tot;
  6. int root[N];
  7. int can[N],cantop;
  8. namespace T
  9. {
  10.     using std::swap;
  12.     int ch[N<<6][2],siz[N<<6];
  13.     int pri[N<<6],val[N<<6];
  14.     ll sum[N<<6];
  15.     bool rev[N<<6];
  17.     int newnode(int v=0)
  18.     {
  19.         int x=cantop?can[cantop--]:++tot;
  20.         ch[x][0]=ch[x][1]=0,siz[x]=1;
  21.         pri[x]=rand()<<15|rand(),val[x]=sum[x]=v;
  22.         rev[x]=0;
  23.         return x;
  24.     }
  26.     int clone(int y)
  27.     {
  28.         int x=cantop?can[cantop--]:++tot;
  29.         ch[x][0]=ch[y][0],ch[x][1]=ch[y][1],siz[x]=siz[y];
  30.         pri[x]=pri[y],val[x]=val[y],sum[x]=sum[y];
  31.         rev[x]=rev[y];
  32.         return x;
  33.     }
  35.     void pushup(int x)
  36.     {
  37.         siz[x]=siz[ch[x][0]]+1+siz[ch[x][1]];
  38.         sum[x]=sum[ch[x][0]]+val[x]+sum[ch[x][1]];
  39.     }
  41.     void pushdown(int x)
  42.     {
  43.         if(rev[x])
  44.         {
  45.             swap(ch[x][0],ch[x][1]);
  46.             if(ch[x][0])
  47.             {
  48.                 ch[x][0]=clone(ch[x][0]);
  49.                 rev[ch[x][0]]^=1;
  50.             }
  51.             if(ch[x][1])
  52.             {
  53.                 ch[x][1]=clone(ch[x][1]);
  54.                 rev[ch[x][1]]^=1;
  55.             }
  56.             rev[x]=0;
  57.         }
  58.     }
  60.     void split(int x,int k,int&l,int&r)
  61.     {
  62.         if(!x)
  63.         {
  64.             l=r=0;
  65.             return;
  66.         }
  67.         pushdown(x);
  68.         if(k<=siz[ch[x][0]])
  69.         {
  70.             r=clone(x);
  71.             split(ch[r][0],k,l,ch[r][0]);
  72.             pushup(r);
  73.         }
  74.         else
  75.         {
  76.             l=clone(x);
  77.             split(ch[l][1],k-siz[ch[x][0]]-1,ch[l][1],r);
  78.             pushup(l);
  79.         }
  80.     }
  82.     int merge(int x,int y)
  83.     {
  84.         if(!x||!y)
  85.             return x+y;
  86.         if(pri[x]<pri[y])
  87.         {
  88.             pushdown(y);
  89.             ch[y][0]=merge(x,ch[y][0]);
  90.             pushup(y);
  91.             return y;
  92.         }
  93.         else
  94.         {
  95.             pushdown(x);
  96.             ch[x][1]=merge(ch[x][1],y);
  97.             pushup(x);
  98.             return x;
  99.         }
  100.     }
  102.     void insert(int&rt,int k,int v)
  103.     {
  104.         int x,y;
  105.         split(rt,k,x,y);
  106.         rt=merge(x,merge(newnode(v),y));
  107.     }
  109.     void erase(int&rt,int p)
  110.     {
  111.         int x,y,z;
  112.         split(rt,p,x,z);
  113.         split(x,p-1,x,y);
  114.         can[++cantop]=y;
  115.         rt=merge(x,z);
  116.     }
  118.     void reverse(int&rt,int l,int r)
  119.     {
  120.         int x,y,z;
  121.         split(rt,r,x,z);
  122.         split(x,l-1,x,y);
  123.         rev[y]^=1;
  124.         rt=merge(x,merge(y,z));
  125.     }
  127.     ll query(int&rt,int l,int r)
  128.     {
  129.         int x,y,z;
  130.         split(rt,r,x,z);
  131.         split(x,l-1,x,y);
  132.         ll ans=sum[y];
  133.         rt=merge(x,merge(y,z));
  134.         return ans;
  135.     }
  136. }
  137. using namespace T;
  138. using namespace std;
  140. int main()
  141. {
  142. //	freopen(".in","r",stdin);
  143. //	freopen(".out","w",stdout);
  144.     int n=read<int>();
  145.     ll lastans=0;
  146.     for(int i=1;i<=n;++i)
  147.     {
  148.         int v,q;
  149.         read(v),read(q);
  150.         root[i]=root[v];
  151.         if(q==1)
  152.         {
  153.             int p,x;
  154.             read(p),read(x);
  155.             p^=lastans,x^=lastans;
  156.             insert(root[i],p,x);
  157.         }
  158.         else if(q==2)
  159.         {
  160.             int p;
  161.             read(p);
  162.             p^=lastans;
  163.             erase(root[i],p);
  164.         }
  165.         else if(q==3)
  166.         {
  167.             int l,r;
  168.             read(l),read(r);
  169.             l^=lastans,r^=lastans;
  170.             reverse(root[i],l,r);
  171.         }
  172.         else
  173.         {
  174.             int l,r;
  175.             read(l),read(r);
  176.             l^=lastans,r^=lastans;
  177.             printf("%lld\n",lastans=query(root[i],l,r));
  178.         }
  179.     }
  180.     return 0;
  181. }

可持久化平衡树

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作（对于各个以往的历史版本）：

  1. 插入x数
  2. 删除x数(若有多个相同的数，因只删除一个，如果没有请忽略该操作)
  3. 查询x数的排名(排名定义为比当前数小的数的个数+1。若有多个相同的数，因输出最小的排名)
  4. 查询排名为x的数
  5. 求x的前驱(前驱定义为小于x，且最大的数，如不存在输出-2147483647)
  6. 求x的后继(后继定义为大于x，且最小的数，如不存在输出2147483647)

和原本平衡树不同的一点是，每一次的任何操作都是基于某一个历史版本，同时生成一个新的版本。（操作3, 4, 5, 6即保持原版本无变化）

每个版本的编号即为操作的序号（版本0即为初始状态，空树）

\(n \leq 5 \times 10^5\)

分析

可以发现非旋Treap的split和merge每次变动的都是一条链。

然后就对这条链可持久化一下就行了。

时空复杂度\(O(n \log n)\)

Hint

注意copy的部分仅限于递归处理的时候，now=0,x=0,y=0这些时候就不用可持久化了，不然会莫名其妙地错。

然后是空间问题，其实3、4、5、6操作不用可持久化，但是平衡树能A就行了，论效率平衡树肯定赶不上其他的做法。

  1. co int MAXN=5e5*50,MAXM=5e5+7; // edit 2
  3. int root[MAXN],tot;
  4. struct Treap
  5. {
  6. 	int ch[MAXN][2],siz[MAXN];
  7. 	int val[MAXN],pri[MAXN];
  9. 	il int newnode(rg int v=0)
  10. 	{
  11. 		++tot;
  12. 		ch[tot][0]=ch[tot][1]=0,siz[tot]=1;
  13. 		val[tot]=v,pri[tot]=rand()|rand()<<16;
  14. 		return tot;
  15. 	}
  17. 	il void pushup(rg int now)
  18. 	{
  19. 		siz[now]=siz[ch[now][0]]+1+siz[ch[now][1]];
  20. 	}
  22. 	il void copy(rg int x,rg int y)
  23. 	{
  24. 		ch[x][0]=ch[y][0],ch[x][1]=ch[y][1],siz[x]=siz[y];
  25. 		val[x]=val[y],pri[x]=pri[y];
  26. 	}
  28. 	il void split(rg int now,rg int v,rg int&x,rg int&y)
  29. 	{
  30. 		if(!now)
  31. 		{
  32. 			x=y=0;
  33. 			return;
  34. 		}
  35. 		if(val[now]<=v)
  36. 		{
  37. 			x=newnode();
  38. 			copy(x,now);
  39. 			split(ch[x][1],v,ch[x][1],y);
  40. 			pushup(x);
  41. 		}
  42. 		else
  43. 		{
  44. 			y=newnode();
  45. 			copy(y,now);
  46. 			split(ch[y][0],v,x,ch[y][0]);
  47. 			pushup(y);
  48. 		}
  49. 	}
  51. 	il int merge(rg int x,rg int y)
  52. 	{
  53. 		if(!x||!y) // edit 1
  54. 			return x+y;
  55. 		rg int now=newnode();
  56. 		if(pri[x]<pri[y])
  57. 		{
  58. 			copy(now,x);
  59. 			ch[now][1]=merge(ch[now][1],y);
  60. 			pushup(now);
  61. 		}
  62. 		else
  63. 		{
  64. 			copy(now,y);
  65. 			ch[now][0]=merge(x,ch[now][0]);
  66. 			pushup(now);
  67. 		}
  68. 		return now;
  69. 	}
  71. 	il void ins(rg int&now,rg int v)
  72. 	{
  73. 		rg int x,y;
  74. 		split(now,v,x,y);
  75. 		now=merge(x,merge(newnode(v),y));
  76. 	}
  78. 	il void del(rg int&now,rg int v)
  79. 	{
  80. 		rg int x,y,z;
  81. 		split(now,v-1,x,y);
  82. 		split(y,v,y,z);
  83. 		y=merge(ch[y][0],ch[y][1]);
  84. 		now=merge(x,merge(y,z));
  85. 	}
  87. 	il int rank(rg int&now,rg int v)
  88. 	{
  89. 		rg int x,y;
  90. 		split(now,v-1,x,y);
  91. 		rg int ans=siz[x]+1;
  92. 		now=merge(x,y);
  93. 		return ans;
  94. 	}
  96. 	il int kth(rg int now,rg int k)
  97. 	{
  98. 		if(!now)
  99. 			return 0;
  100. 		while(k)
  101. 		{
  102. 			if(siz[ch[now][0]]>=k)
  103. 				now=ch[now][0];
  104. 			else if(siz[ch[now][0]]+1==k)
  105. 				return now;
  106. 			else
  107. 			{
  108. 				k-=siz[ch[now][0]]+1;
  109. 				now=ch[now][1];
  110. 			}
  111. 		}
  112. 		return now;
  113. 	}
  115. 	il int pre(rg int&now,rg int v)
  116. 	{
  117. 		rg int x,y;
  118. 		split(now,v-1,x,y);
  119. 		rg int ans=kth(x,siz[x]);
  120. 		now=merge(x,y);
  121. 		return ans;
  122. 	}
  124. 	il int suc(rg int&now,rg int v)
  125. 	{
  126. 		rg int x,y;
  127. 		split(now,v,x,y);
  128. 		rg int ans=kth(y,1);
  129. 		now=merge(x,y);
  130. 		return ans;
  131. 	}
  132. }T;
  134. int main()
  135. {
  136. //	freopen(".in","r",stdin);
  137. //	freopen(".out","w",stdout);
  138. 	srand(20030506);
  139. 	rg int n;
  140. 	read(n);
  141. 	for(rg int i=1;i<=n;++i)
  142. 	{
  143. 		rg int v,opt,x;
  144. 		read(v);read(opt);read(x);
  145. //		cerr<<"v="<<v<<" opt="<<opt<<" x="<<x<<endl;
  146. 		root[i]=root[v];
  147. 		if(opt==1) // insert
  148. 		{
  149. 			T.ins(root[i],x);
  150. 		}
  151. 		else if(opt==2) // delete
  152. 		{
  153. 			T.del(root[i],x);
  154. 		}
  155. 		else if(opt==3) // rank
  156. 		{
  157. 			printf("%d\n",T.rank(root[i],x));
  158. 		}
  159. 		else if(opt==4) // kth
  160. 		{
  161. 			printf("%d\n",T.val[T.kth(root[i],x)]);
  162. 		}
  163. 		else if(opt==5) // pre
  164. 		{
  165. 			int ans=T.pre(root[i],x);
  166. 			if(ans==0)
  167. 				puts("-2147483647");
  168. 			else
  169. 				printf("%d\n",T.val[ans]);
  170. 		}
  171. 		else if(opt==6) // suf
  172. 		{
  173. 			int ans=T.suc(root[i],x);
  174. 			if(ans==0)
  175. 				puts("2147483647");
  176. 			else
  177. 				printf("%d\n",T.val[ans]);
  178. 		}
  179. 	}
  180. 	return 0;
  181. }

再分析

然而对这题而言有更优的做法，主席树（可持久化权值线段树）。

将权值离散化，得到了这题较优的做法。

但是要离线，所以也是个问题。不离线的话空间会大一些，问题不大。

时间复杂度\(O(n \log n)\)，常数小多了。

Hint

注意调用查询的时候，边界问题。

另外“若有多个相同的数，因只删除一个，如果没有请忽略该操作”。这个神坑点卡了我好久，非旋式Treap会自动忽略不存在的，所以就没管。

  1. co int MAXN=5e5*20,MAXM=5e5+7;
  3. int v[MAXN],opt[MAXN],x[MAXN];
  4. vector<int>xlist;
  6. int root[MAXM],tot;
  7. struct SegTree
  8. {
  9. 	int sumv[MAXN];
  10. 	int L[MAXN],R[MAXN];
  12. 	il void pushup(rg int now)
  13. 	{
  14. 		sumv[now]=sumv[L[now]]+sumv[R[now]];
  15. //		assert(sumv[now]>=0);
  16. 	}
  18. 	il void copy(rg int x,rg int y)
  19. 	{
  20. 		sumv[x]=sumv[y];
  21. 		L[x]=L[y],R[x]=R[y];
  22. 	}
  24. 	il void modify(rg int&now,rg int l,rg int r,rg int p,rg int v)
  25. 	{
  26. 		++tot;
  27. 		copy(tot,now);
  28. 		now=tot;
  29. 		if(l==r)
  30. 		{
  31. 			sumv[now]+=v;
  32. 			return;
  33. 		}
  34. 		rg int m=(l+r)>>1;
  35. 		if(p<=m)
  36. 			modify(L[now],l,m,p,v);
  37. 		else
  38. 			modify(R[now],m+1,r,p,v);
  39. 		pushup(now);
  40. 	}
  42. 	il int sum(rg int now,rg int l,rg int r,rg int ql,rg int qr)
  43. 	{
  44. 		if(ql<=l&&r<=qr)
  45. 			return sumv[now];
  46. 		rg int m=(l+r)>>1;
  47. 		if(qr<=m)
  48. 			return sum(L[now],l,m,ql,qr);
  49. 		if(ql>=m+1)
  50. 			return sum(R[now],m+1,r,ql,qr);
  51. 		return sum(L[now],l,m,ql,qr)+sum(R[now],m+1,r,ql,qr);
  52. 	}
  54. 	il int kth(rg int now,rg int l,rg int r,rg int k)
  55. 	{
  56. 		if(l==r)
  57. 			return l;
  58. 		rg int m=(l+r)>>1;
  59. 		if(sumv[L[now]]>=k)
  60. 			return kth(L[now],l,m,k);
  61. 		else
  62. 		{
  63. 			k-=sumv[L[now]];
  64. 			return kth(R[now],m+1,r,k);
  65. 		}
  66. 	}
  68. 	il int pre(rg int root,rg int p)
  69. 	{
  70. 		rg int num=p>1?sum(root,1,xlist.size(),1,p-1):0; // edit 1:notice p=1
  71. 		if(num==0) // do not exist
  72. 			return 0;
  73. 		else
  74. 			return kth(root,1,xlist.size(),num);
  75. 	}
  77. 	il int suc(rg int root,rg int p)
  78. 	{
  79. 		rg int num=p<xlist.size()?sum(root,1,xlist.size(),p+1,xlist.size()):0; // edit 2:notice p=xlist.size()
  80. 		if(num==0) // do not exist
  81. 			return xlist.size()+1;
  82. 		else
  83. 			return kth(root,1,xlist.size(),sumv[root]-num+1);
  84. 	}
  85. }T;
  87. int main()
  88. {
  89. //	freopen(".in","r",stdin);
  90. //	freopen(".out","w",stdout);
  91. 	rg int n;
  92. 	read(n);
  93. 	for(rg int i=1;i<=n;++i)
  94. 	{
  95. 		read(v[i]);read(opt[i]);read(x[i]);
  96. 		if(opt[i]!=4) // unless kth
  97. 			xlist.push_back(x[i]);
  98. 	}
  99. 	sort(xlist.begin(),xlist.end());
  100. 	xlist.erase(unique(xlist.begin(),xlist.end()),xlist.end());
  101. 	for(rg int i=1;i<=n;++i)
  102. 	{
  103. 		if(opt[i]!=4)
  104. 			x[i]=lower_bound(xlist.begin(),xlist.end(),x[i])-xlist.begin()+1;
  105. //		cerr<<"x "<<i<<" = "<<x[i]<<endl;
  106. 		root[i]=root[v[i]];
  107. 		if(opt[i]==1) // insert
  108. 		{
  109. 			T.modify(root[i],1,xlist.size(),x[i],1);
  110. 		}
  111. 		else if(opt[i]==2) // delete
  112. 		{
  113. 			// edit 3:if this val do not exist, you should ignore this operation
  114. 			if(T.sum(root[i],1,xlist.size(),x[i],x[i])==0)
  115. 				continue;
  116. 			T.modify(root[i],1,xlist.size(),x[i],-1);
  117. 		}
  118. 		else if(opt[i]==3) // rank
  119. 		{
  120. 			printf("%d\n",1+(x[i]>1?T.sum(root[i],1,xlist.size(),1,x[i]-1):0)); // edit 1: notice x[i]=1
  121. 		}
  122. 		else if(opt[i]==4) // kth
  123. 		{
  124. //			assert(1<=x[i]&&x[i]<=T.sumv[root[i]]);
  125. 			printf("%d\n",xlist[T.kth(root[i],1,xlist.size(),x[i])-1]);
  126. 		}
  127. 		else if(opt[i]==5) // pre
  128. 		{
  129. 			int ans=T.pre(root[i],x[i]);
  130. 			if(ans!=0)
  131. 				printf("%d\n",xlist[ans-1]);
  132. 			else
  133. 				puts("-2147483647");
  134. 		}
  135. 		else if(opt[i]==6) // suc
  136. 		{
  137. 			int ans=T.suc(root[i],x[i]);
  138. 			if(ans!=xlist.size()+1)
  139. 				printf("%d\n",xlist[ans-1]);
  140. 			else
  141. 				puts("2147483647");
  142. 		}
  143. 	}
  144. 	return 0;
  145. }

三分析

其实树状数组也可以做，并且常数更小。

但是空间就必须提前开出来，并且不离线不行了。

然后不用可持久化，可以搞一个dfs。给时间点连上边，dfs的时候就修改+撤销就行了。

第一次知道这么精妙的做法，那线段树、平衡树貌似都可以这么搞，并且空间复杂度大为减小。

分享一下洛谷全站最快代码，by Mr_Spade


  2. const int N=5e5+5;
  3. int n,m,lgn;
  4. int num[N],tot;
  5. int bit[N];
  6. inline void add(int x,int k)
  7. {
  8.     while(x<=n)
  9.         bit[x]+=k,x+=x&-x;
  10.     return;
  11. }
  12. inline int ask(int x)
  13. {
  14.     int res=0;
  15.     while(x)
  16.         res+=bit[x],x&=x-1;
  17.     return res;
  18. }
  19. inline int find(int x)
  20. {
  21.     int res=0;
  22.     for(int i=lgn;~i;i--)
  23.         if((res|1<<i)<=n&&bit[res|1<<i]<x)
  24.             x-=bit[res|=1<<i];
  25.     return res+1;
  26. }
  27. struct oper
  28. {
  29.     int opt,x;
  30. }o[N];
  31. int first[N],next[N];
  32. int ans[N];
  33. void dfs(int now)
  34. {
  35.     int d=0;
  36.     register int go;
  37.     for(go=first[now];go;go=next[go])
  38.     {
  39.         switch(o[go].opt)
  40.         {
  41.             case 1:add(o[go].x,1);break;
  42.             case 2:
  43.                 if(ask(o[go].x)^ask(o[go].x-1))
  44.                     add(o[go].x,-1);
  45.                 else
  46.                     d=1;
  47.                 break;
  48.             case 3:ans[go]=ask(o[go].x-1)+1;break;
  49.             case 4:ans[go]=num[find(o[go].x)];break;
  50.             case 5:
  51.                 if(!(d=ask(o[go].x-1)))
  52.                     ans[go]=-0x7fffffff;
  53.                 else
  54.                     ans[go]=num[find(d)];
  55.                 break;
  56.             case 6:
  57.                 if((d=ask(o[go].x))==ask(n))
  58.                     ans[go]=0x7fffffff;
  59.                 else
  60.                     ans[go]=num[find(d+1)];
  61.                 break;
  62.         }
  63.         dfs(go);
  64.         switch(o[go].opt)
  65.         {
  66.             case 1:add(o[go].x,-1);break;
  67.             case 2:
  68.                 if(!d)
  69.                     add(o[go].x,1);
  70.                 break;
  71.         }
  72.     }
  73.     return;
  74. }
  75. signed main()
  76. {
  77.     fseek(stdin,0l,2);
  78.     int len=ftell(stdin);
  79.     rewind(stdin);
  80.     fread(in,1,len,stdin);
  81.     int x;
  82.     register int i;
  83.     m=read();
  84.     for(i=1;i<=m;i++)
  85.     {
  86.         next[i]=first[x=read()];first[x]=i;
  87.         o[i].opt=read();o[i].x=read();
  88.         if(o[i].opt^4)
  89.             num[++tot]=o[i].x;
  90.     }
  91.     sort(num+1,num+tot+1);
  92.     n=unique(num+1,num+tot+1)-num-1;
  93.     for(lgn=1;1<<lgn<=n;lgn++);lgn--;
  94.     for(i=1;i<=m;i++)
  95.         if(o[i].opt^4)
  96.             o[i].x=lower_bound(num+1,num+n+1,o[i].x)-num;
  97.     dfs(0);
  98.     for(i=1;i<=m;i++)
  99.         if(o[i].opt!=1&&o[i].opt!=2)
  100.             write(ans[i]),putchar('\n');
  101.     fwrite(out,1,fout,stdout);
  102.     return 0;
  103. }

这题的bug

正如上面看到的，这题可以乱搞。所以出题人要是想考察可持久化平衡树的话，最好还是强制在线，另外为了卡掉线段树还有01Trie，可以把节点弄成双键值，比如一个pair。

另外一个有趣的问题：持久化fhq treap在合并时不需要复制节点。正如我所说的：“这跟这题的单点插入有关，如果是单点插入那么相当于要插入的新节点无论如何都复制好了，换句话说隐式的新建了一个节点。但是如果是插入一段新节点的话就错了，因为这段的新节点没有隐式复制。”

讨论

文艺平衡树（Splay）

您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：翻转一个区间，例如原有序序列是5 4 3 2 1，翻转区间是[2,4]的话，结果是5 2 3 4 1

\(n,m \leq 1e5\)

分析

Splay Tree实现。

时间复杂度均摊\(O(\log n)\)

  1. typedef long long ll;
  3. co int N=1e5+7;
  4. namespace T
  5. {
  6. 	using std::swap;
  8. 	int rt;
  9. 	int fa[N],ch[N][2],siz[N];
  10. 	bool rev[N];
  12. 	void pushup(int x)
  13. 	{
  14. 		siz[x]=siz[ch[x][0]]+1+siz[ch[x][1]];
  15. 	}
  17. 	void pushdown(int x)
  18. 	{
  19. 		if(rev[x])
  20. 		{
  21. 			swap(ch[x][0],ch[x][1]);
  22. 			rev[ch[x][0]]^=1;
  23. 			rev[ch[x][1]]^=1;
  24. 			rev[x]=0;
  25. 		}
  26. 	}
  28. 	void rotate(int x,int&k)
  29. 	{
  30. 		int y=fa[x],z=fa[y],d=ch[y][0]==x;
  31. 		if(y==k)
  32. 			k=x;
  33. 		else
  34. 		{
  35. 			if(ch[z][0]==y)
  36. 				ch[z][0]=x;
  37. 			else
  38. 				ch[z][1]=x;
  39. 		}
  40. 		ch[y][d^1]=ch[x][d],fa[ch[y][d^1]]=y;
  41. 		ch[x][d]=y,fa[y]=x,fa[x]=z;
  42. 		pushup(x);
  43. 		pushup(y);
  44. 	}
  46. 	void splay(int x,int&k)
  47. 	{
  48. 		while(x!=k)
  49. 		{
  50. 			int y=fa[x],z=fa[y];
  51. 			if(y!=k)
  52. 			{
  53. 				if((ch[y][0]==x)^(ch[z][0]==y))
  54. 					rotate(x,k);
  55. 				else
  56. 					rotate(y,k);
  57. 			}
  58. 			rotate(x,k);
  59. 		}
  60. 	}
  62. 	void build(int l,int r,int f)
  63. 	{
  64. 		if(l>r)
  65. 			return;
  66. 		int mid=(l+r)/2;
  67. 		if(mid<f)
  68. 			ch[f][0]=mid;
  69. 		else
  70. 			ch[f][1]=mid;
  71. 		fa[mid]=f,siz[mid]=1;
  72. 		if(l==r)
  73. 			return;
  74. 		build(l,mid-1,mid);
  75. 		build(mid+1,r,mid);
  76. 		pushup(mid);
  77. 	}
  79. 	int find(int x,int k)
  80. 	{
  81. 		pushdown(x);
  82. 		int s=siz[ch[x][0]];
  83. 		if(k==s+1)
  84. 			return x;
  85. 		if(k<=s)
  86. 			return find(ch[x][0],k);
  87. 		else
  88. 			return find(ch[x][1],k-s-1);
  89. 	}
  91. 	void rever(int l,int r)
  92. 	{
  93. 		int x=find(rt,l),y=find(rt,r+2);
  94. 		splay(x,rt);
  95. 		splay(y,ch[x][1]);
  96. 		int z=ch[y][0];
  97. 		rev[z]^=1;
  98. 	}
  99. }
  100. using namespace T;
  101. using namespace std;
  103. int main()
  104. {
  105. //	freopen(".in","r",stdin);
  106. //	freopen(".out","w",stdout);
  107. 	int n,m;
  108. 	read(n),read(m);
  109. 	rt=(n+3)/2;
  110. 	build(1,n+2,rt);
  111. 	while(m--)
  112. 	{
  113. 		int l,r;
  114. 		read(l),read(r);
  115. 		rever(l,r);
  116. 	}
  117. 	for(int i=2;i<=n+1;++i)
  118. 		printf("%d ",find(rt,i)-1);
  119. 	return 0;
  120. }

普通平衡树

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：

  1. 插入x数
  2. 删除x数(若有多个相同的数，因只删除一个)
  3. 查询x数的排名(排名定义为比当前数小的数的个数+1。若有多个相同的数，因输出最小的排名)
  4. 查询排名为x的数
  5. 求x的前驱(前驱定义为小于x，且最大的数)
  6. 求x的后继(后继定义为大于x，且最小的数)

\(n \leq 10^5\)

分析

用范浩强Treap实现。具体原理：





















范浩强对函数式编程在OI中的应用做了很好的引入工作。

非旋式Treap的精华在于那个merge。

merge的参数要求保证x中最大的数不大于y中最小的数。

这样在合并一个子树的时候，有两种等价情况，一种是x是y的左儿子，一种是y是x的右儿子。

选择的依据是priority，这样平衡的道理就跟普通Treap一样了。

  1. const int INF=0x7fffffff;
  3. const int MAXN=1e5+7;
  5. int sz;
  6. struct Treap
  7. {
  8. 	int val[MAXN],pri[MAXN];
  9. 	int ch[MAXN][2],siz[MAXN];
  11. 	void pushup(int x)
  12. 	{
  13. 		siz[x]=siz[ch[x][0]]+1+siz[ch[x][1]];
  14. 	}
  16. 	int new_node(int v)
  17. 	{
  18. 		val[++sz]=v,
  19. 		pri[sz]=rand()<<15|rand();
  20. 		ch[sz][0]=ch[sz][1]=0,
  21. 		siz[sz]=1;
  22. 		return sz;
  23. 	}
  25. 	int merge(int x,int y)
  26. 	{
  27. 		if(!x||!y)
  28. 			return x+y;
  29. 		if(pri[x]<pri[y])
  30. 		{
  31. 			ch[x][1]=merge(ch[x][1],y);
  32. 			pushup(x);
  33. 			return x;
  34. 		}
  35. 		else
  36. 		{
  37. 			ch[y][0]=merge(x,ch[y][0]);
  38. 			pushup(y);
  39. 			return y;
  40. 		}
  41. 	}
  43. 	void split(int now,int v,int&x,int&y)
  44. 	{
  45. 		if(!now)
  46. 			x=y=0;
  47. 		else
  48. 		{
  49. 			if(val[now]<=v)
  50. 			{
  51. 				x=now,split(ch[now][1],v,ch[now][1],y);
  52. 			}
  53. 			else
  54. 			{
  55. 				y=now,split(ch[now][0],v,x,ch[now][0]);
  56. 			}
  57. 			pushup(now);
  58. 		}
  59. 	}
  61. 	void ins(int&now,int v)
  62. 	{
  63. 		int x,y;
  64. 		split(now,v,x,y);
  65. 		now=merge(merge(x,new_node(v)),y);
  66. 	}
  68. 	void del(int&now,int v)
  69. 	{
  70. 		int x,y,z;
  71. 		split(now,v,x,z);
  72. 		split(x,v-1,x,y);
  73. 		y=merge(ch[y][0],ch[y][1]);
  74. 		now=merge(merge(x,y),z);
  75. 	}
  77. 	int rank(int&now,int v)
  78. 	{
  79. 		int x,y;
  80. 		split(now,v-1,x,y);
  81. 		int ans=siz[x]+1;
  82. 		now=merge(x,y);
  83. 		return ans;
  84. 	}
  86. 	int kth(int now,int k)
  87. 	{
  88. 		while(1)
  89. 		{
  90. 			if(k<=siz[ch[now][0]])
  91. 				now=ch[now][0];
  92. 			else if(k==siz[ch[now][0]]+1)
  93. 				return now;
  94. 			else
  95. 				k-=siz[ch[now][0]]+1,now=ch[now][1];
  96. 		}
  97. 	}
  99. 	int pre(int&now,int v)
  100. 	{
  101. 		int x,y;
  102. 		split(now,v-1,x,y);
  103. 		int ans=kth(x,siz[x]);
  104. 		now=merge(x,y);
  105. 		return ans;
  106. 	}
  108. 	int suc(int&now,int v)
  109. 	{
  110. 		int x,y;
  111. 		split(now,v,x,y);
  112. 		int ans=kth(y,1);
  113. 		now=merge(x,y);
  114. 		return ans;
  115. 	}
  116. }T;
  118. int main()
  119. {
  120. //  freopen(".in","r",stdin);
  121. //  freopen(".out","w",stdout);
  122. 	srand(20030506);
  123. 	int root=0;
  124. 	int n;
  125. 	read(n);
  126. 	while(n--)
  127. 	{
  128. 		static int opt,x;
  129. 		read(opt);read(x);
  130. 		if(opt==1) // insert
  131. 		{
  132. 			T.ins(root,x);
  133. 		}
  134. 		else if(opt==2) // delete
  135. 		{
  136. 			T.del(root,x);
  137. 		}
  138. 		else if(opt==3) // rank
  139. 		{
  140. 			printf("%d\n",T.rank(root,x));
  141. 		}
  142. 		else if(opt==4) // kth
  143. 		{
  144. 			printf("%d\n",T.val[T.kth(root,x)]);
  145. 		}
  146. 		else if(opt==5) // precursor
  147. 		{
  148. 			printf("%d\n",T.val[T.pre(root,x)]);
  149. 		}
  150. 		else // successor
  151. 		{
  152. 			printf("%d\n",T.val[T.suc(root,x)]);
  153. 		}
  154. 	}
  155. //  fclose(stdin);
  156. //  fclose(stdout);
  157.     return 0;
  158. }

LG3835 【模板】可持久化平衡树的更多相关文章

  1. 【LG3835】可持久化平衡树

    [LG3835]可持久化平衡树 题面 洛谷 解法一 参考文章 rope大法好 \(rope\)基本操作: #include<ext/rope> using namespace __gnu_ ...

  2. luoguP3835 [模板]可持久化平衡树

    https://www.luogu.org/problemnew/show/P3835 因为博主精力和实力有限,学不懂 fhq treap 了,因此只介绍 leafy tree 解法 leafy tr ...

  3. 洛谷.3835.[模板]可持久化平衡树(fhq treap)

    题目链接 对每次Merge(),Split()时产生的节点都复制一份(其实和主席树一样).时间空间复杂度都为O(qlogq).(应该更大些 因为rand()?内存真的爆炸..) 对于无修改的操作实际上 ...

  4. luogu P3919 [模板]可持久化数组(可持久化线段树/平衡树)(主席树)

    luogu P3919 [模板]可持久化数组(可持久化线段树/平衡树) 题目 #include<iostream> #include<cstdlib> #include< ...

  5. Luogu P3835 【模板】可持久化平衡树(fhq Treap)

    P3835 [模板]可持久化平衡树 题意 题目背景 本题为题目普通平衡树的可持久化加强版. 题目描述 您需要写一种数据结构(可参考题目标题),来维护一些数,其中需要提供以下操作(对于各个以往的历史版本 ...

  6. [Luogu 3835]【模板】可持久化平衡树

    Description 您需要写一种数据结构(可参考题目标题),来维护一些数,其中需要提供以下操作(对于各个以往的历史版本): 插入x数 删除x数(若有多个相同的数,因只删除一个,如果没有请忽略该操作 ...

  7. 洛谷P3835 【模板】可持久化平衡树

    题目背景 本题为题目 普通平衡树 的可持久化加强版. 数据已经经过强化 感谢@Kelin 提供的一组hack数据 题目描述 您需要写一种数据结构(可参考题目标题),来维护一些数,其中需要提供以下操作( ...

  8. P3835 【模板】可持久化平衡树

    题目描述 您需要写一种数据结构(可参考题目标题),来维护一些数,其中需要提供以下操作(对于各个以往的历史版本): 插入x数 删除x数(若有多个相同的数,因只删除一个,如果没有请忽略该操作) 查询x数的 ...

  9. 2021.07.02 P1383 高级打字机题解（可持久化平衡树）

    2021.07.02 P1383 高级打字机题解(可持久化平衡树) 分析: 从可以不断撤销并且查询不算撤销这一骚操作可以肯定这是要咱建一棵可持久化的树(我也只会建可持久化的树,当然,还有可持久化并查集 ...

随机推荐

  1. 以普通用户启动的Vim如何保存需要root权限的文件

    在Linux上工作的朋友很可能遇到过这样一种情况,当你用Vim编辑完一个文件时,运行:wq保存退出,突然蹦出一个错误: E45: 'readonly' option is set (add ! to ...

  2. nodejs pm2配置使用

    nodejs pm2配置使用教程参考链接:http://www.111cn.net/sys/linux/100927.htm 安装步骤: yum -y install npmnpm install - ...

  3. 当vue路由变化时 改变导航条式样

    这个是导航栏: <router-link to="/unusedOrder"> <div class="">路由1</div> ...

  4. Java环境搭建---（基础）

    首先下载eclipse开发工具,下载地址:http://www.eclipse.org/downloads/,界面如下: 选择eclipse juno(4.2)的版本进入界面 点击Downloads, ...

  5. hdu3718

    题解: 见图 按照每一个位置上有相同加一 然后km 代码: #include<cstdio> #include<cmath> #include<cstring> # ...

  6. Bootstrap modal 多弹窗之叠加关闭阴影遮罩问题的解决方法

    这里也会遇到一次性关闭所有modal引起阴影遮罩的问题,也就是所有modal都关闭了,但是主页面仍然被阴影遮罩. 这个问题从哪来的,是因为modal叠加,我们点击窗口之外的空白部分,一次性关闭所有mo ...

  7. jauery-layer弹出框的使用

    一布局: <div id="detailLayer"> <div class="box-header"> <div class=& ...

  8. [置顶] kubernetes1.7新特性：PodDisruptionBudget控制器变化

    背景概念 在Kubernetes中,为了保证业务不中断或业务SLA不降级,需要将应用进行集群化部署.通过PodDisruptionBudget控制器可以设置应用POD集群处于运行状态最低个数,也可以设 ...

  9. 用两个stack实现一个队列

    class Queue { stack<int> input, output; public: void push(int x) { input.push(x); } void pop(v ...

  10. puremvc源码阅读

    1.mediator作为ui管理器,是设计成可以list多个notification 2.所有ui想要监听notification,都需要register到facade中 3.puremvc只负责消息 ...