浅谈 van Emde Boas 树——从 u 到 log log u 的蜕变

本文参考算法导论完成。

模板题在此 QwQ

优化的过程比较长，还请读者耐心阅读，认真理解。

最初的想法

我会暴力！

用一个 \(size\) 数组维护每个元素出现的次数。

不细讲，时间复杂度 \(O(um)\)。

树形结构

不难发现，刚刚的算法的本质是将值域划分成了值域大小块。

将 \(0\sim u-1\) 看做一个结点，它有 \(u\) 个儿子，第 \(i\) 个儿子所代表的值域为 \(i-1\sim i-1\)。

给每个结点编号，稍稍改变一下 \(size\) 数组的定义。此时 \(size_i\) 表示第 \(i\) 个结点所代表的值域中每个值出现的次数之和。

可以发现，这是一棵两层的树，除叶子结点外，每个结点都有 \(u\) 个儿子。

而这个算法的瓶颈就在于找出一个结点第一棵、最后一棵有值的子树，一棵子树之前、之后第一棵有值的子树。

那是否可以将结点的儿子数量减小，从而得到更优的复杂度呢？答案是肯定的。

如果儿子变成 \(2\) 个，那这就是一棵权值线段树，瓶颈变成了树的深度，时间复杂度 \(O(m\log u)\)。如果儿子变成 \(\lceil\sqrt u\rceil\) 个，瓶颈依旧在于儿子数量，时间复杂度 \(O(m\sqrt u)\)。

前者会更加优秀，但正是因为后者，才有了之后的改进。

递归结构

总结一下前一节的内容，树形结构遇到了两方面的瓶颈，即树的深度和儿子数量。而我们很难在树的深度上获得什么突破，那就只好限制树的深度了。

考虑采用递归结构，对于每个结点，我们都将它的值域分成值域大小的平方根块，然后递归下去，直到值域大小小于等于 \(2\)。

根据开方的性质，树的深度被限制在了 \(\log\log u\)。

解决完深度后，如何突破儿子数量的瓶颈呢？

考虑对于每一个非叶结点，除了它的儿子，再新建一棵 \(summary\) 子树，结构与其它子树相同，值域大小为其它子树的个数，维护其它子树内是否有值。

注意，这同样是递归结构，\(summary\) 子树内依旧可能会有 \(summary\) 子树。

所以求一个结点第一棵、最后一棵有值的子树，一棵子树之前、之后第一棵有值的子树就转化成了求 \(summary\) 子树内同样的问题，而 \(summary\) 子树的值域大小在原树的基础上有很大的缩减。

于是原型 van Emde Boas 结构就出现了，具体内容会在下一节中介绍。

构建原型 van Emde Boas 结构

令 \(p=\lceil\sqrt u\rceil\)。

定义值域 \(0\sim u-1\) 为一个原型 van Emde Boas 结构或 proto-vEB 结构，记做 \(proto-vEB(u)\)，称一个结构为一个簇。

• \(u=2\)，\(proto-vEB(u)\) 是叶子结点，包含一个大小为 \(2\) 的数组 \(a_{0\sim 1}\)，表示值 \(0\) 和 \(1\) 的出现次数。

• \(u>2\)，\(proto-vEB(u)\) 包含一个大小为 \(\lceil\frac{u}{p}\rceil\) 的数组 \(cluster_{0\sim\lceil\frac{u}{p}\rceil-1}\) 表示 \(proto-vEB(u)\) 的 \(\lceil\frac{u}{p}\rceil\) 个子簇的编号，前 \(\lfloor\frac{u}{p}\rfloor\) 个子簇都是一个 \(proto-vEB(p)\)，如果最后多出来的一个子簇存在那么它的大小为 \(\max(u\bmod p,2)\)。

  另外，\(proto-vEB(u)\) 还包含一个大小为 \(\lceil\frac{u}{p}\rceil\) 的子簇 \(summary\)，\(summary\) 也是一个 \(proto-vEB\) 结构。

  为了方便快捷地支持删除值后 \(summary\) 的更新问题（不能直接删，因为对应簇中可能有多个值），\(proto-vEB(u)\) 还有一个 \(size\) 表示值域中每个值出现的次数之和。

但这样会出现一个新问题：如何得知当前值所在的位置？或者说，如何得知某个位置所代表的值？

首先注意一点：值都是相对于当前簇的，要知道真实的意义必须向上运算至最近的 \(summary\) 的顶部（此时是对上一层值的一个统计）或整个簇（全域）的顶部（此时是真实元素）。

考虑这个运算。第 \(x(0\leq x<\lceil\frac{u}{p}\rceil)\) 个子簇中值 \(y\) 相对于当前层的值是 \(xp+y\)。

反过来也一样，当前层的值 \(x\) 应该在第 \(\lfloor\frac{x}{p}\rfloor\) 个子簇中，相对于这个子簇的值为 \(x\bmod p\)。

理清楚这些概念后，就可以来康代码了。

proto-vEB 结构：

struct proto_vEB
{
	vector<int>clu;
	int a[2],u,sqr,sum,siz;
}t[2001005];

因为 \(cluster\) 的大小不确定所以我们用了个 vector 来实现。

建树：

void create(proto_vEB&v,int u)
{
	v.u=Max(u,2);
	if(u>2)
	{
		int i;
		v.sqr=int(sqrt(Db(u)));
		if(v.sqr*v.sqr<u)v.sqr++;
		For(i,1,u/v.sqr)v.clu.push_back(++cnt),create(t[cnt],v.sqr);
		if(u%v.sqr)v.clu.push_back(++cnt),create(t[cnt],u%v.sqr);
		v.sum=++cnt;
		create(t[cnt],u/v.sqr+(u%v.sqr>0));
	}
}

用到的结点数量是 \(S(u)=S(\lceil\sqrt u\rceil)\times\lfloor\frac{u}{\lceil\sqrt u\rceil}\rfloor+S(u\bmod\lceil\sqrt u\rceil))+S(\lceil\frac{u}{\lceil\sqrt u\rceil}\rceil)+1\)，这东西还不是单调的。有没有鸽鸽能来指教一下 \(1\sim u\) 的上界大概是多少啊/kel

原型 van Emde Boas 结构上的操作

有点复杂，直接对着代码讲解。

为了方便，我们首先用三个函数表示上文提到过的运算。

inline int high(proto_vEB&v,int x)
{
	return x/v.sqr;
}
inline int low(proto_vEB&v,int x)
{
	return x%v.sqr;
}
inline int index(proto_vEB&v,int x,int y)
{
	return x*v.sqr+y;
}

查询某个值出现的次数

int member(proto_vEB&v,int x)
{
	if(v.u==2)return v.a[x];
	return member(t[v.clu[high(v,x)]],low(v,x));
}

第三行处理叶子结点的情况。

第四行在 \(x\) 所在的子簇内继续查找。

查找簇内最小值

int minimum(proto_vEB&v)
{
	if(v.u==2)return(v.a[0]?0:(v.a[1]?1:-1));
	int mn=minimum(t[v.sum]);
	return(!~mn?-1:index(v,mn,minimum(t[v.clu[mn]])));
}

第三行处理叶子结点的情况。

第四行查找第一个有值的子簇。

第五行在该子簇内继续查找。

查找簇内最大值

int maximum(proto_vEB&v)
{
	if(v.u==2)return(v.a[1]?1:(v.a[0]?0:-1));
	int mx=maximum(t[v.sum]);
	return(!~mx?-1:index(v,mx,maximum(t[v.clu[mx]])));
}

与最小值对称。

查找簇内某个值的前驱

int predecessor(proto_vEB&v,int x)
{
	if(v.u==2)return(x&&v.a[0]?0:-1);
	int rem=predecessor(t[v.clu[high(v,x)]],low(v,x));
	if(~rem)return index(v,high(v,x),rem);
	rem=predecessor(t[v.sum],high(v,x));
	return(!~rem?-1:index(v,rem,maximum(t[v.clu[rem]])));
}

第三行处理叶子结点的情况。

第四行在 \(x\) 所在的子簇内查找前驱。

第五行判断是否找到，找到了就直接返回。

第六行在前面的子簇中查找最近的有值的子簇。

第七行在该子簇内查找最大值。

查找簇内某个值的后继

int successor(proto_vEB&v,int x)
{
	if(v.u==2)return(!x&&v.a[1]?1:-1);
	int rem=successor(t[v.clu[high(v,x)]],low(v,x));
	if(~rem)return index(v,high(v,x),rem);
	rem=successor(t[v.sum],high(v,x));
	return(!~rem?-1:index(v,rem,minimum(t[v.clu[rem]])));
}

与前驱对称。

插入一个值

int insert(proto_vEB&v,int x,bool rem)
{
	if(v.u==2)if(rem)
	{
		v.a[x]++;
		return 1;
	}
	else
	{
		if(v.a[x])return 0;
		v.a[x]=1;
		return 1;
	}
	else
	{
		int p=insert(t[v.clu[high(v,x)]],low(v,x),rem),q=insert(t[v.sum],high(v,x),0);
		t[v.clu[high(v,x)]].siz+=p;
		t[v.sum].siz+=q;
		return p+q;
	}
}

该函数的返回值表示该子簇内新插入的值的数量。

第三至十三行处理叶子结点的情况。

\(rem\) 表示当前簇是否处于某个 \(summary\) 内。

如果没有，说明此处存储的是某个元素出现的次数，可以大于 \(1\)。

否则仅仅需要判断是否出现，不可以大于 \(1\)。

第十六行往 \(x\) 所在的子簇和 \(summary\) 内插入对应的值，同时统计新插入的值的数量。

第十七和十八行更新 \(size\)。

第十九行返回当前簇新插入的值的数量。

删除一个值

int Delete(proto_vEB&v,int x)
{
	if(v.u==2)if(v.a[x])
	{
		v.a[x]--;
		return 1;
	}
	else return 0;
	else
	{
		int p=Delete(t[v.clu[high(v,x)]],low(v,x)),q=0;
		t[v.clu[high(v,x)]].siz-=p;
		if(!t[v.clu[high(v,x)]].siz)q=Delete(t[v.sum],high(v,x));
		t[v.sum].siz-=q;
		return p+q;
	}
}

该函数的返回值表示该子簇内新删除的值的数量。

第三至八行处理叶子结点的情况。

如果 \(a_x>0\) 说明可以删除就删除返回 \(1\)，否则返回 \(0\)。

第十一行去 \(x\) 所在的子簇中删除对应的值，同时统计新删除的值的数量。

第十二行更新 \(x\) 所在的子簇的 \(size\)。

第十三行判断 \(x\) 所在的子簇是否为空，为空就在 \(summary\) 中删除对应的值，同时统计新删除的值的数量。

第十四行更新 \(summary\) 的 \(size\)。

第十五行返回当前簇新删除的值的数量。

时间复杂度分析

member：\(T(u)=T(\sqrt u)+O(1)\)，花费 \(O(\log\log u)\)。

minimum maximum insert Delete：\(T(u)=2T(\sqrt u)+O(1)\)，花费 \(O(\log u)\)。

predecessor successor：\(T(u)=2T(\sqrt u)+O(\log u)\)，花费 \(O(\log u\log\log u)\)。

还需要继续改进。

van Emde Boas 结构成型

发现 proto-vEB 不够优秀的原因是因为有些操作我们需要多次递归，我们想要尽可能减少递归。

考虑多记录两个量，簇内的最小值 \(mn\) 和最大值 \(mx\)。

需要注意的是，\(mn\) 不出现在簇中，而 \(mx\) 出现在簇中，即该簇中（不包含该簇）不会有任何一个 \(mn\) 或 \(mx\) 等于该簇的 \(mn\)，该簇中某个簇（包含该簇）的 \(mn\) 一定会等于该簇的 \(mx\)。

簇的 \(mn\) 与 \(mx\) 不包含 \(summary\) 中的值。

这样做是有原因的：

1. minimum 和 maximum 甚至不需要递归，可以直接用。

2. predecessor 和 successor 可以直接判断前驱和后继是否在 \(x\) 所在的子簇中，不需要递归。

3. 可以 \(O(1)\) 判断一个簇的状态。如果 \(mn\) 和 \(mx\) 都不存在，那么簇为空；如果 \(mn=mx\)，那么簇仅包含一个值；如果 \(mn\) 和 \(mx\) 不相等，那么簇包含至少两个值。

4. 可以 \(O(1)\) 将一个值插入一个空簇中。

van Emde Boas 结构上的操作

细节很多，依旧来看每个操作。

查询某个值出现的次数

int member(vEB&v,int x)
{
	return(x==v.mn?v.a[0]:(x==v.mx?v.a[1]:(v.u==2?0:member(t[v.clu[high(v,x)]],low(v,x)))));
}

第三行先判断是否是簇内值的个数小于等于 \(2\) 或叶子结点的情况，是就返回，不是就在 \(x\) 所在的子簇内继续查找。

查找簇内某个值的后继

int successor(vEB&v,int x)
{
	if(v.u==2)return(!x&&v.mx==1?1:-1);
	if(x<v.mn)return v.mn;
	int rem=t[v.clu[high(v,x)]].mx;
	if(~rem&&low(v,x)<rem)return index(v,high(v,x),successor(t[v.clu[high(v,x)]],low(v,x)));
	rem=successor(t[v.sum],high(v,x));
	return(!~rem?-1:index(v,rem,t[v.clu[rem]].mn));
}

第三行处理叶子结点的情况。

第四行处理后继是 \(mn\) 的情况。

第六行判断后继是否在 \(x\) 所在的子簇内，是就在 \(x\) 所在的子簇内继续查找后继。

第七行在之后的子簇内查找最近有值的子簇。

第八行返回该子簇的 \(mn\)。

查找簇内某个值的前驱

int predecessor(vEB&v,int x)
{
	if(v.u==2)return(x&&!v.mn?0:-1);
	if(~v.mx&&x>v.mx)return v.mx;
	int rem=t[v.clu[high(v,x)]].mn;
	if(~rem&&low(v,x)>rem)return index(v,high(v,x),predecessor(t[v.clu[high(v,x)]],low(v,x)));
	rem=predecessor(t[v.sum],high(v,x));
	return(!~rem?(v.mn<x?v.mn:-1):index(v,rem,t[v.clu[rem]].mx));
}

同后继，但要注意一种情况，即之前的子簇中都无值。

此时 \(x\) 的前驱可能是 \(mn\)（因为 \(mn\) 不在簇中嘛），在第八行中多判断了一下。

插入一个值

void insert(vEB&v,int x,int y,bool bo)
{
	if(!bo)y=1;
	if(!~v.mn)
	{
		v.mn=v.mx=x;
		v.a[0]=v.a[1]=y;
		return;
	}
	if(x==v.mn)
	{
		if(bo)
		{
			v.a[0]+=y;
			if(v.mn==v.mx)v.a[1]+=y;
		}
		return;
	}
	if(x<v.mn)
	{
		if(v.mn==v.mx&&bo)v.a[1]=0;
		swap(x,v.mn),swap(v.a[0],y);
	}
	if(v.u>2)
	{
		int rem=v.clu[high(v,x)];
		if(!~t[rem].mn)insert(t[v.sum],high(v,x),y,0);
		insert(t[rem],low(v,x),y,bo);
	}
	if(x>v.mx)v.mx=x,v.a[1]=y;
	else if(x==v.mx&&bo)v.a[1]+=y;
}

既然都能直接判断簇的状态了，那还要 \(size\) 何用？但是代码更长了（悲

我们依旧记录当前簇是否处于某个 \(summary\) 内，用 \(bo\) 表示。另外，\(y\) 表示插入值的个数。

第三行因为 \(summary\) 中值出现次数只能为一次，所以处理一下。

第四至九行处理簇内无值的情况。注意 \(mn\) 和 \(mx\) 的出现次数都要变成 \(y\)！

第十至十八行处理 \(x=mn\) 的情况。

第十二行判断是否在 \(summary\) 内，只有不在 \(summary\) 内才能增加出现次数（原先出现次数至少为 \(1\)）。

第十四行更新 \(mn\) 的出现次数。

第十五行注意当 \(mn=mx\) 时同时更新 \(mx\) 的出现次数！

第十九至二十三行处理 \(x<mn\) 的情况。

第二十一行插个眼。

第二十二行更新 \(mn\)。注意是交换，因为如果 \(mn\) 被更新了，原先的 \(mn\) 依旧还存在，要传下去。且传下去必定能插入，因为相同的值没有被传下去过。

第二十四行判断是否是叶子结点，不是才能继续插下去。

第二十七行在 \(x\) 所在子簇为空的情况下更新 \(summary\)。

第二十八行去 \(x\) 所在的子簇内插。

第三十行更新 \(mx\)。

第三十一行更新 \(mx\) 的出现次数，此处拔起第二十一行的眼。我们发现执行第二十一行时互换了 \(x\) 和 \(mn\)，如果原先 \(mn=mx\)，那第三十一行实际出现次数没有变化的 \(mx\)（即原 \(mn\)）的出现次数会重复叠加。所以要在第二十一行特判这种情况，提前将 \(mx\) 的出现次数清空，这样就不会受到影响了。

删除一个值

void Delete(vEB&v,int x,bool bo)
{
	if(v.mn==v.mx)
	{
		if(!~v.mn)return;
		if(x!=v.mn)return;
		if(bo||v.a[0]==1)v.mn=v.mx=-1;
		else v.a[0]--,v.a[1]--;
		return;
	}
	if(v.u==2)
	{
		if(!x)if(bo||v.a[0]==1)v.mn=1,v.a[0]=v.a[1];
		else v.a[0]--;
		else if(bo||v.a[1]==1)v.mx=v.mn,v.a[1]=v.a[0];
		else v.a[1]--;
		return;
	}
    int rem;
	if(x==v.mn)
	{
		if(!bo&&v.a[0]>1)
		{
			v.a[0]--;
			return;
		}
		rem=t[v.sum].mn;
		x=index(v,rem,t[v.clu[rem]].mn);
		v.mn=x;
		v.a[0]=t[v.clu[rem]].a[0];
		bo=1;
	}
	rem=v.clu[high(v,x)];
	Delete(t[rem],low(v,x),bo);
	if(!~t[rem].mn)
	{
		Delete(t[v.sum],high(v,x),bo);
		if(x==v.mx)
		{
			if(!bo&&v.a[1]>1)
			{
				v.a[1]--;
				return;
			}
			rem=t[v.sum].mx;
			if(!~rem)v.mx=v.mn,v.a[1]=v.a[0];
			else v.mx=index(v,rem,t[v.clu[rem]].mx),v.a[1]=t[v.clu[rem]].a[1];
		}
	}
	else if(v.mx==x)
	{
		if(!bo&&v.a[1]>1)
		{
			v.a[1]--;
			return;
		}
        rem=v.clu[high(v,x)];
		v.mx=index(v,high(v,x),t[rem].mx);
		v.a[1]=t[rem].a[1];
	}
}

真就长那么亿点点（

实在讲不动了，就自己理解吧，能有耐心看到这我相信各位都能自己写出来了。我只把坑点说一下。

首先，如果删除后更新了 \(mn\)，那么要将簇中存在的最小值变成 \(mn\)，然后删除它。此时要删完，即该值不管出现几次都清空，因为次数也跟着变成 \(mn\) 的出现次数了。所以我们用一个 \(bo\) 表示是否要删完。

第七行要同时清空 \(mn\) 和 \(mx\)。

第八行要同时更新 \(mn\) 和 \(mx\) 的次数。

第十三和十五行更新 \(mn\) 或 \(mx\) 时记得同时更新出现次数。

第三十一行在更新完 \(mn\) 后记得将 \(bo\) 置为 \(1\)。

第三十八行记得更新 \(mx\)，此处的情况是 \(x\) 所在的子簇内已无值，\(mx\) 为前面最后一个有值的子簇的 \(mx\)。

第五十行记得更新 \(mx\)，此处的情况是 \(x\) 所在的子簇内还有值，\(mx\) 直接为该子簇的 \(mx\)。

时间复杂度分析

member：\(T(u)=T(\sqrt u)+O(1)\)，花费 \(O(\log\log u)\)。

predecessor successor：\(T(u)=T(\sqrt u)+O(1)\)，花费 \(O(\log\log u)\)。

insert Delete：虽然看起来有两次调用，但分析后会发现有一个只需要花费常数时间，所以 \(T(u)=T(\sqrt u)+O(1)\)，花费 \(O(\log\log u)\)。

总时间复杂度 \(O(m\log\log u)\)，非常优秀。

后记

这个算法我啃了好几天，虽然在 OI 中用处不大，但也算是自己的一个增长点吧。

另外，这个算法的思想和改进思路也是值得借鉴的。限制一部分，优化一部分。

在优化这方面，为什么会想到用值域的平方根来作为下一层的大小呢？其实这取决于 \(summary\)。在想到用 \(summary\) 来优化同一层的查找后，递归就分成了两部分，一部分是 \(summary\)，另一部分是 \(summary\) 中每个值对应的值域区间。这两部分当然尽可能均匀越好喽，所以就取了平方根。

最后成型的 \(mn\) 和 \(mx\) 让查询变得非常快速，\(mn\) 不会出现在簇中让更新变得非常快速，不得不说非常非常巧妙。

只剩必要的一条递归。

将信息利用到了极致。