平衡树

平衡树

• 定义

  全称为二叉平衡搜索树。

• 二叉搜索树

  形式化的，这个概念是指一棵节点带权的二叉树，令节点 \(i\) 的权值为 \(w_i\)，左子树点集为 \(L\)，右子树点集为 \(R\)，其满足 \(\forall u \in L,w_u \le w_i\) 且 \(\forall v \in R,w_v > w_i\)。

• 性质 / 作用

  • 具备单调性，可实现 \(\log\) 级别复杂度的查找。

  • 中序遍历单调不减，于是可以与一个序列形成映射（将下标作为权值即可）。

• 平衡的意义

  众所周知，一个序列对应的二叉搜索树不一定惟一。我们希望取得高度更小的那一棵，以保证复杂度。

  若一棵二叉树的任意节点 \(i\)，其左右子树高度差 \(\Delta h \le 1\)，则我们称其为一棵二叉平衡树。

• 常用的平衡树

  treap、fhq-treap、splay。

FHQ-Treap

• 定义

  又称无旋 Treap。即仅靠分裂与合并完成维护。

• \(\operatorname{split}(k,a,b,val)\)

  顾名思义，即将根节点为 \(k\) 的 tree 分裂成根节点为 \(a,b\) 的两棵 tree，点集为 \(A,B\)，其中 \(\forall u \in A, w_u \le val\) 且 \(\forall v \in B, w_v > val\)。

  大体的思路就是 \(k\) 为当前节点，若 \(w_k \le val\)，说明找到了 \(a\)，并且其左子树也都在 \(A\) 中，然后去右子树中寻找 \(b\) 和 \(A\) 所缺的右子树。找到了 \(b\) 则反之处理即可。

• \(\operatorname{merge}(k,a,b)\)

  顾名思义，即将根节点为 \(a,b\) 的 tree 合并为根节点为 \(k\) 的 tree，点集为 \(A,B\)，其中 \(\forall u \in A,v \in B,w_u \le w_v\)。

  根据定义，肯定是 \(A\) 左 \(B\) 右了，但是高度无法确定。

  于是，我们给每个节点随机一个 \(rank\)，谁 \(rank\) 小谁就在高处，这样退化成一条链的几率很小，可以保证均摊复杂度 \(\log\) 级别。

  确定了高度，譬如 \(A\) 在上，那么 \(B\) 就需要和 \(A\) 的右子树继续竞争，递归下去即可。

这两个函数是 FHQ-Treap 的精髓之所在。

其他的因题而异，请自行阅读代码进行理解。本代码只给出函数部分。

实现

void upd(int k){
	tree[k].siz=tree[tree[k].lt].siz+tree[tree[k].rt].siz+1;
}
int add_node(int val){
	tree[++tot].siz=1;
	tree[tot].val=val;
	tree[tot].rnk=rand();
	tree[tot].lt=tree[tot].rt=0;
	return tot;
}
void split(int k,int &a,int &b,int val){
	if(!k){
		a=b=0;
		return;
	}
	if(tree[k].val<=val){
		a=k;
		split(tree[k].rt,tree[k].rt,b,val);
	}
	else{
		b=k;
		split(tree[k].lt,a,tree[k].lt,val);
	}
	upd(k);
}
void merge(int &k,int a,int b){
	if(!a||!b){
		k=a+b;
		return;
	}
	if(tree[a].rnk<tree[b].rnk){
		k=a;
		merge(tree[k].rt,tree[k].rt,b);
	}
	else{
		k=b;
		merge(tree[k].lt,a,tree[k].lt);
	}
	upd(k);
}
void ins(int &k,int val){
	int a=0,b=0,cur=add_node(val);
	split(k,a,b,val);
	merge(a,a,cur);
	merge(k,a,b);
}
void del(int &k,int val){
	int a=0,b=0,c=0;
	split(k,a,b,val);
	split(a,a,c,val-1);
	merge(c,tree[c].lt,tree[c].rt);
	merge(a,a,c);
	merge(k,a,b);
}
int fnd_rnk(int &k,int val){
	int a=0,b=0;
	split(k,a,b,val-1);
	int res=tree[a].siz+1;
	merge(k,a,b);
	return res;
}
int fnd_num(int k,int x){
	while(tree[tree[k].lt].siz+1!=x){
		if(tree[tree[k].lt].siz>=x)
			k=tree[k].lt;
		else{
			x-=tree[tree[k].lt].siz+1;
			k=tree[k].rt;
		}
	}
	return tree[k].val;
}
int pre(int &k,int val){
	int a=0,b=0;
	split(k,a,b,val-1);
	int res=fnd_num(a,tree[a].siz);
	merge(k,a,b);
	return res;
}
int suf(int &k,int val){
	int a=0,b=0;
	split(k,a,b,val);
	int res=fnd_num(b,1);
	merge(k,a,b);
	return res;
}

应用

P1486（整体修改、第 \(K\) 大）

看到如上的关键词，我们考虑用一棵平衡树维护工资档案。

具体的：

• I k：新建并插入一个节点。

• A k：维护一个 \(tag\) 表示整体修改的值，令 \(tag+k \to tag\)。

• S k：令 \(tag-k \to tag\)，并删除权值 \(< min-tag\)（注意不是 \(<min\)）的所有节点。

• F k：查询第 \(k\) 大即可。

实现

#include<bits/stdc++.h>
#define int long long
using namespace std;
 
const int N=1e5+5;
int n,ans,root,tot,mini,tag,all;
struct fhq{
	int val,rnk,siz,lt,rt;
}tree[N];
 
int add_node(int val){
	tree[++tot].val=val,all++;
	tree[tot].siz=1;
	tree[tot].rnk=rand();
	tree[tot].lt=tree[tot].rt=0;
	return tot;
}
void upd(int k){
	tree[k].siz=tree[tree[k].lt].siz+tree[tree[k].rt].siz+1;
}
void split(int k,int &a,int &b,int val){
	if(!k){
		a=b=0;
		return;
	}
	if(tree[k].val<=val){
		a=k;
		split(tree[k].rt,tree[k].rt,b,val);
	}
	else {
		b=k;
		split(tree[k].lt,a,tree[k].lt,val);
	}
	upd(k);
}
void merge(int &k,int a,int b){
	if(!a||!b){
		k=a+b;
		return;
	}
	if(tree[a].rnk<tree[b].rnk){
		k=a;
		merge(tree[k].rt,tree[k].rt,b);
	}
	else {
		k=b;
		merge(tree[k].lt,a,tree[k].lt);
	}
	upd(k);
}
void ins(int &k,int val){
	int a=0,b=0,cur=add_node(val);
	split(k,a,b,val);
	merge(a,a,cur);
	merge(k,a,b);
}
void del(int &k){
	int a=0,b=0;
	split(k,a,b,mini-tag-1);
	ans+=tree[a].siz;
	all-=tree[a].siz;
	k=b;
}
int fnd_num(int k,int x){
	while(tree[tree[k].rt].siz+1!=x){
		if(tree[tree[k].rt].siz>=x)
			k=tree[k].rt;
		else{
			x-=tree[tree[k].rt].siz+1;
			k=tree[k].lt;
		}
	}
	return tree[k].val;
}
 
signed main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	srand(time(0));
	cin>>n>>mini;
	add_node(-1e18),add_node(1e18);
	all=0;
	while(n--){
		char x; int k;
		cin>>x>>k;
		if(x=='I'&&k>=mini)
			ins(root,k-tag);
		else if(x=='A')
			tag+=k;
		else if(x=='S')
			tag-=k,del(root);
		else if(x=='F'){
			if(all<k)
				cout<<"-1\n";
			else
				cout<<fnd_num(root,k)+tag<<'\n';
		}
	}
	cout<<ans;
	return 0;
} 

总结：

• 第 \(K\) 大考虑平衡树。

• 整体修改考虑给整棵树打标记。

P2234（前驱、后继）

我们仍然考虑使用一棵平衡树维护营业额。

对于每天的营业额，我们顺次插入平衡树，然后在其前驱和后继这两个之间找差最小的即可。

需要注意的是：

• 如果前面出现过相同的营业额，绝对差直接为 \(0\)。

• 应当设置哨兵节点以防找不到前驱 / 后继。

实现

总结：

• 差最小考虑平衡树维护前驱 / 后继。

P3224（与 DSU 的结合）

还是查询第 \(K\) 小，考虑平衡树维护。

很容易想到对于每个联通块建一棵平衡树，然后用并查集维护联通性（合并）的时候顺便把树也合并了。

但是，我们的 merge 函数只能接受满足 \(\forall u \in A,v \in B,u<v\) 的点集为 \(A,B\) 的两棵树进行合并，可联通块并不具有此种性质。

于是启发式合并，将较小的树的点一个一个地扔进较大的树中即可，时间复杂度是 \(\log\) 级别的（一个点至多会被合并 \(\log n\) 次，因为每次合并都会使大小翻倍）。

实现

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#define int long long
using namespace std;
 
const int N=2e5+5;
int n,m,q;
int root[N],fa[N],tot;
struct fhq{
	int val,rnk,siz,lt,rt,id;
}tree[N<<2];
 
int fnd(int x){
	return (fa[x]==x?x:fa[x]=fnd(fa[x]));
}
int add_node(int val,int id){
	tree[++tot].val=val;
	tree[tot].siz=1;
	tree[tot].rnk=rand();
	tree[tot].lt=tree[tot].rt=0;
	tree[tot].id=id;
	return tot;
}
void upd(int k){
	tree[k].siz=tree[tree[k].lt].siz+tree[tree[k].rt].siz+1;
}
void split(int k,int &a,int &b,int val){
	if(!k){
		a=b=0;
		return;
	}
	if(tree[k].val<=val){
		a=k;
		split(tree[k].rt,tree[k].rt,b,val);
	}
	else {
		b=k;
		split(tree[k].lt,a,tree[k].lt,val);
	}
	upd(k);
}
void merge(int &k,int a,int b){
	if(!a||!b){
		k=a+b;
		return;
	}
	if(tree[a].rnk<tree[b].rnk){
		k=a;
		merge(tree[k].rt,tree[k].rt,b);
	}
	else {
		k=b;
		merge(tree[k].lt,a,tree[k].lt);
	}
	upd(k);
}
void ins(int &k,int val,int id){
	int a=0,b=0,cur=add_node(val,id);
	split(k,a,b,val);
	merge(a,a,cur);
	merge(k,a,b);
}
void cls(int x){
	tree[x].val=tree[x].rnk=tree[x].siz=tree[x].lt=tree[x].rt=tree[x].id=0;
}
void mrg(int x,int y){
	x=fnd(x),y=fnd(y);
	if(x==y)
		return;
	if(tree[root[y]].siz>tree[root[x]].siz)
		swap(x,y);
	fa[y]=x;
	while(1){
		ins(root[x],tree[root[y]].val,tree[root[y]].id);
		cls(root[y]);
		merge(root[y],tree[root[y]].lt,tree[root[y]].rt);
		if(!root[y]){
			root[y]=root[x];
			break;
		}
	}
}
int fnd_num(int k,int x){
	while(tree[tree[k].lt].siz+1!=x){
		if(tree[tree[k].lt].siz>=x)
			k=tree[k].lt;
		else{
			x-=tree[tree[k].lt].siz+1;
			k=tree[k].rt;
		}
	}
	return tree[k].id;
}
 
signed main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	srand(time(0));
	cin>>n>>m;
	for(int i=1,x;i<=n;i++)
		cin>>x,root[i]=i,fa[i]=i,add_node(x,i);
	for(int i=1,u,v;i<=m;i++)
		cin>>u>>v,mrg(u,v);
	cin>>q;
	while(q--){
		char opt; int x,y;
		cin>>opt>>x>>y;
		if(opt=='Q')
			cout<<(tree[root[fnd(x)]].siz<y?-1:fnd_num(root[fnd(x)],y))<<'\n';
		else
			mrg(x,y);
	}
	return 0;
} 

总结：

• merge 不行，启发式合并来凑。

P3391（区间翻转问题、按 size 分裂）

首先，我们考虑将序列映射到这棵平衡树的中序遍历上。

这样，按照 \([1,r] \to [l,r]\) 的方式分裂两次即可得到 \([l,r]\) 区间。

然后翻转这东西，它就像异或一样，做两次相当于没做。

于是我们考虑对每个节点打标记，于是每次反转操作只需要分出区间再更新标记（别忘了把当前节点的左右子树反过来）即可。

哦对了，最后输出的时候可以一边中序遍历、一边继续下传标记（中间不一定下传完了）。

关于实现，分裂的时候需要写一个按 size 分裂的 fhq-treap，具体看代码8。

实现

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#define int long long
using namespace std;
 
const int N=1e5+5;
int n,m,root,tot;
struct fhq{
	int val,rnk,siz,lt,rt,tag;
}tree[N];
 
int add_node(int val){
	tree[++tot].val=val;
	tree[tot].siz=1;
	tree[tot].rnk=rand();
	tree[tot].lt=tree[tot].rt=0;
	return tot;
}
void pushup(int k){
	tree[k].siz=tree[tree[k].lt].siz+tree[tree[k].rt].siz+1;
}
void pushdown(int k){
	if(!tree[k].tag)
		return;
	swap(tree[k].lt,tree[k].rt);
	tree[tree[k].lt].tag^=1;
	tree[tree[k].rt].tag^=1;
	tree[k].tag=0;
}
void split(int k,int &a,int &b,int x){
	if(!k){
		a=b=0;
		return;
	}
	pushdown(k);
	if(tree[tree[k].lt].siz+1>x){
		b=k;
		split(tree[k].lt,a,tree[k].lt,x);
	}
	else {
		a=k;
		split(tree[k].rt,tree[k].rt,b,x-tree[tree[k].lt].siz-1);
	}
	pushup(k);
}
void merge(int &k,int a,int b){
	if(!a||!b){
		k=a+b;
		return;
	}
	pushdown(a);
	pushdown(b);
	if(tree[a].rnk<tree[b].rnk){
		k=a;
		merge(tree[k].rt,tree[k].rt,b);
	}
	else {
		k=b;
		merge(tree[k].lt,a,tree[k].lt);
	}
	pushup(k);
}
void ins(int &k,int val){
	int a=0,b=0,cur=add_node(val);
	split(k,a,b,val);
	merge(a,a,cur);
	merge(k,a,b);
}
void qry(int &k,int l,int r){
	int a=0,b=0,c=0;
	split(k,a,b,r);
	split(a,a,c,l-1);
	tree[c].tag^=1;
	merge(a,a,c);
	merge(k,a,b);
}
void dfs(int k){
	if(!k)
		return;
	pushdown(k);
	dfs(tree[k].lt);
	cout<<k<<' ';
	dfs(tree[k].rt);
}
 
signed main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	srand(time(0));
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		ins(root,i);
	for(int i=1,l,r;i<=m;i++){
		cin>>l>>r;
		qry(root,l,r);
	}
	dfs(root);
	return 0;
} 

总结：

• 序列问题考虑映射到平衡树的中序遍历上，以及使用按 size 分裂的。

• 数据结构注重打标记（对每个节点打标记最常见），然后注意下传。

P5217（按 size 分裂查排名、状压思想）

全家桶了属于是。

插入、删除、翻转、查排名对应的字母都不讲。

P 操作就是查字母对应的排名，具体而言就是从 \(x\) 开始，若它是右儿子，那么不停地往上跳，然后累加左子树的节点数，很容易理解吧。特别注意翻转标记必须先下传完再处理这个操作，不然会导致「当前文本」不是真正的当前文本。

Q 操作这种种类数的询问显然考虑状压维护，每次 pushup 时或一下左右子树的二进制值再传给父亲即可。

实现

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
//#define int long long
using namespace std;
 
const int N=2e5+5;
int n,m,tot,root;
string str;
struct fhq{
	int tag,val,rnk,lt,rt,siz,word,fa;
}tree[N];
void pushup(int k){
	if(tree[k].lt)
		tree[tree[k].lt].fa=k;
	if(tree[k].rt)
		tree[tree[k].rt].fa=k;
	tree[k].word=tree[tree[k].lt].word|tree[tree[k].rt].word|1<<tree[k].val;
	tree[k].siz=tree[tree[k].lt].siz+tree[tree[k].rt].siz+1;
}
void pushdown(int k){
	if(!tree[k].tag)
		return;
	swap(tree[k].lt,tree[k].rt);
	tree[tree[k].lt].tag^=1;
	tree[tree[k].rt].tag^=1;
	tree[k].tag=0;
}
int add_node(int val){
	tree[++tot].siz=1;
	tree[tot].lt=tree[tot].rt=0;
	tree[tot].word=0;
	tree[tot].val=val;
	tree[tot].rnk=rand();
	tree[tot].tag=0;
	pushup(tot);
	return tot;
}
void split(int k,int &a,int &b,int x){
	if(!k){
		a=b=0;
		return;
	}
	pushdown(k);
	if(tree[tree[k].lt].siz+1>x){
		b=k;
		split(tree[k].lt,a,tree[k].lt,x);
		tree[a].fa=0;
	}
	else{
		a=k;
		split(tree[k].rt,tree[k].rt,b,x-tree[tree[k].lt].siz-1);
		tree[b].fa=0;
	}
	pushup(k);
}
void merge(int &k,int a,int b){
	if(!a||!b){
		k=a+b;
		return;
	}
	pushdown(a),pushdown(b);
	if(tree[a].rnk<tree[b].rnk){
		k=a;
		merge(tree[k].rt,tree[k].rt,b);
	}
	else{
		k=b;
		merge(tree[k].lt,a,tree[k].lt);
	}
	pushup(k);
}
void dddd(int k){
	if(tree[k].fa)
		dddd(tree[k].fa);
	pushdown(k);
}
void dfs(int k){
	if(!k)
		return;
	pushdown(k);
	dfs(tree[k].lt);
	cout<<(char)(tree[k].val+'a');
	dfs(tree[k].rt); 
}
 
 
signed main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	srand(time(0));
	cin>>n>>m>>str;
	str='#'+str;
	for(int i=1;i<=n;i++)
		merge(root,root,add_node(str[i]-'a'));
	while(m--){
		char op,ch;
		int x,y,a=0,b=0,c=0;
		cin>>op>>x;
		if(op=='I'){
			cin>>ch;
			split(root,a,b,x);
			merge(a,a,add_node(ch-'a'));
			merge(root,a,b);
		}
		else if(op=='D'){
			split(root,a,b,x);
			split(a,a,c,x-1);
			tree[c].val=-1;
			merge(root,a,b);
		}
		else if(op=='R'){
			cin>>y;
			split(root,a,b,y);
			split(a,a,c,x-1);
			tree[c].tag^=1;
			merge(a,a,c);
			merge(root,a,b);
		}
		else if(op=='P'){
			if(tree[x].val==-1){
				cout<<"0\n";
				continue;
			}
			dddd(x);
			int res=tree[tree[x].lt].siz+1;
			for(int i=x;tree[i].fa;i=tree[i].fa)
				if(tree[tree[i].fa].rt==i)
					res+=tree[tree[tree[i].fa].lt].siz+1;
			cout<<res<<'\n';
		}
		else if(op=='T'){
			split(root,a,b,x);
			split(a,a,c,x-1);
			cout<<(char)(tree[c].val+'a')<<'\n';
			merge(a,a,c);
			merge(root,a,b);
		}
		else if(op=='Q'){
			cin>>y;
			split(root,a,b,y);
			split(a,a,c,x-1);
			cout<<__builtin_popcount(tree[c].word)<<'\n';
			merge(a,a,c);
			merge(root,a,b);
		}
		//dfs(root);
		//cout<<'\n';
	}
	return 0;
}

总结：

• 积累了按 size 分裂的 fhq_treap 如何查排名。

• 种类数的维护考虑状压。

P3765（摩尔投票、随机化）

积累一个摩尔投票（求区间内绝对众数）的 trick：

在一个区间内，首先令第一个元素为答案；维护一个 \(cnt\)，之后每遇到一个与答案相同的，\(cnt+1 \to cnt\)，否则 \(cnt-1 \to cnt\)。若 \(cnt=0\)，则令当前这个为答案，继续重复上述步骤，最后的答案就有可能为绝对众数。正确性显然。

很容易发现摩尔投票具有区间可加性，我们就可以使用线段树维护绝对众数。具体而言，若两个区间众数相同，则合起来众数不变、\(cnt\) 相加；否则众数为较大的那个、\(cnt\) 为绝对差。这样在保证存在绝对众数的情况下，可以做到 \(O(1)\) 回答询问。

问题是现在无法保证存在绝对众数，于是我们需要进行验证，也就是验证求出的众数是否真的有 \(r-l+1\) 个人投他。考虑使用平衡树维护之，将每个人插入他投的那个人的平衡树中，于是问题等价于询问排名 \(l \sim r\) 中是否有 \(r-l+1\) 个人，所以我们需要 \(n\) 棵按 val 分裂的平衡树（方便查找排名）。

然后这个题就做完了，但是巨大难写，怎么办？

考虑乱搞。具体的，我们完全可以不需要线段树维护区间绝对众数，我们直接随机一个，再用平衡树检查。只随机一次的错误概率为 \(\frac{1}{2}\)，这样重复 \(15 \sim 20\) 次，错误概率最低仅为 \(\frac{1}{2^{20}}\)，几乎可以忽略不计。

实现

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
//#define int long long
using namespace std;
 
inline int read()
{
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0' && ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return x*f;
}
 
void write(int x)
{
    if(x<0)
        putchar('-'),x=-x;
    if(x>9)
        write(x/10);
    putchar(x%10+'0');
    return;
}
 
const int N=5e6+5;
int n,m,root,tot;
int a[N];
bool vis[N];
struct FHQ{
	int val,rnk,siz,lt,rt;
}tree[N];
struct fhq{
	int root=0;
	int add_node(int val){
		tree[++tot].val=val;
		tree[tot].siz=1;
		tree[tot].rnk=rand();
		tree[tot].lt=tree[tot].rt=0;
		return tot;
	}
	void upd(int k){
		tree[k].siz=tree[tree[k].lt].siz+tree[tree[k].rt].siz+1;
	}
	void split(int k,int &a,int &b,int val){
		if(!k){
			a=b=0;
			return;
		}
		if(tree[k].val<=val){
			a=k;
			split(tree[k].rt,tree[k].rt,b,val);
		}
		else {
			b=k;
			split(tree[k].lt,a,tree[k].lt,val);
		}
		upd(k);
	}
	void merge(int &k,int a,int b){
		if(!a||!b){
			k=a+b;
			return;
		}
		if(tree[a].rnk<tree[b].rnk){
			k=a;
			merge(tree[k].rt,tree[k].rt,b);
		}
		else {
			k=b;
			merge(tree[k].lt,a,tree[k].lt);
		}
		upd(k);
	}
	void ins(int val){
		int a=0,b=0,cur=add_node(val);
		split(root,a,b,val);
		merge(a,a,cur);
		merge(root,a,b);
	}
	void del(int val){
		int a=0,b=0,c=0;
		split(root,a,b,val);
		split(a,a,c,val-1);
		merge(c,tree[c].lt,tree[c].rt);
		merge(a,a,c);
		merge(root,a,b);
	}
	int fnd_rnk(int val){
		int a=0,b=0;
		split(root,a,b,val);
		int res=tree[a].siz;
		merge(root,a,b);
		return res;
	}
}tr[N];
 
int qry(int l,int r){
	int res=-1,stk[30]={0},top=0;
	for(int i=1;i<=15;i++){
		int seed=a[rand()%(r-l+1)+l];
		if(vis[seed])
			continue;
		vis[seed]=1,stk[++top]=seed;
		if(tr[seed].fnd_rnk(r)-tr[seed].fnd_rnk(l-1)>(r-l+1)/2){
			res=seed;
			break;
		}
	}
	while(top)
		vis[stk[top]]=0,top--;
	return res;
}
 
signed main(){
	srand(time(0));
	n=read(),m=read();
	for(int i=1;i<=n;i++)
		a[i]=read(),tr[a[i]].ins(i);
	for(int i=1,l,r,s,k;i<=m;i++){
		l=read(),r=read(),s=read(),k=read();
		int winner=qry(l,r);
		if(winner==-1)
			winner=s;
		for(int j=1,x;j<=k;j++)
			x=read(),tr[a[x]].del(x),a[x]=winner,tr[winner].ins(x);
		write(winner),putchar('\n');
	}
	write(qry(1,n));
	return 0;
} 

总结：

• 区间绝对众数：摩尔投票 / 随机化。

• 注意平衡树的使用是按 size（一般用于序列问题） 还是 val（一般用于查排名、前驱、后继等） 分裂。