O(1)判断两点之间是否有边

O(1)判断两点之间是否有边

问题描述

给定一张 \(n\) 个点，\(m\) 条边的有向图。

多次询问，要求每次 \(\mathcal{O}(1)\) 判断两点之间是否有边（你可以忽略输入、输出等问题）。

数据范围：\(2\leq n\leq 4\times 10^5\)，\(0\leq m\leq 8\times 10^5\)。

空间限制：\(512\texttt{MB}\)。

做法

朴素做法有三种：

• 对每个点 \(u\)，用一个 \(\texttt{vector}\) 存从它出发的边。将这些边按另一端点的大小排序。每次查询时，在 \(u\) 的 \(\texttt{vector}\) 里二分查找。这样单次询问的时间复杂度是 \(\mathcal{O}(\log n)\) 的。如果对每个点维护一个 \(\texttt{map}\) 或 \(\texttt{set}\)，本质是一样的。
• 用一个二维 \(\texttt{bool}\) 型数组 \(\texttt{a[u][v]}\)，表示点 \(u, v\) 之间是否有边。这样单次询问时间复杂度是 \(\mathcal{O}(1)\) 的，但是空间复杂度高达 \(\mathcal{O}(n^2)\)，无法承受。
• 哈希。本文不讨论。

考虑将前两种做法结合。

设 \(x = 11\)。把每 \(2^x\) 个点分为一类。这样共有 \(\frac{n}{2^x}\) 类。用一个大小为 \(\frac{n^2}{2^x}\) 的数组，就能实现判断：每个点向每一类点之间是否有连边。

如果一个点 \(u\) 向某一类点 \(t\) 之间有连边，我们称之为一个“事件”。容易发现，事件至多只有 \(m\) 个。

考虑每个事件，它对应的入点至多只有 \(2^x\) 个。将这 \(2^x\) 个点再分类。把每 \(2^6\) 个点分为一类，会分出 \(2^{x - 6}\) 类。每一类点里编号都小于 \(2^6 = 64\)。一个 \(\texttt{unsigned long long}\) 有 \(64\) 位，所以刚好可以用一个 \(\texttt{unsigned long long}\) 描述其状态。

在上述做法里，我们总共需要 \(\frac{n^2}{2^x}\) 个 \(\texttt{int}\)，和 \(m\cdot 2^{x - 6}\) 个 \(\texttt{unsigned long long}\)。为了估算方便，不妨假设 \(m = 2n\)。那么所需的字节数是：\(4\cdot \frac{n^2}{2^x} + 8\cdot 2n\cdot 2^{x - 6}\)，令他们相等，解得 \(x = 11\) 时该式取到最小值。刚好 \(500\texttt{MB}\) 不到。

参考代码：

const int MAXN = 4e5, MAXM = 8e5;
const int FULL5 = (1 << 5) - 1;
const int FULL6 = (1 << 6) - 1;

int b1[MAXN + 5][MAXN / (1 << 11) + 5], cnt_b1;
ull b2[MAXM + 5][FULL5 + 1];

void add_edge(int u, int v) {
	if (!b1[u][v >> 11]) b1[u][v >> 11] = ++cnt_b1;
	b2[b1[u][v >> 11]][(v >> 6) & FULL5] |= 1ull << (v & FULL6);
}
bool have_edge(int u, int v) {
	if (!b1[u][v >> 11]) return false;
	return b2[b1[u][v >> 11]][(v >> 6) & FULL5] & (1ull << (v & FULL6));
}

另外，\(n\leq 2\times 10^5\)，\(m\leq 4\times 10^5\) 时，上述代码只需要改变 MAXN 和 MAXM 的值，其他参数不变，空间消耗就降到 \(171\texttt{MB}\) 了。

进一步的思考

上述做法里，我们只分了两层，这是为了介绍该算法的核心思路。其实，如果不考虑时间上的常数，我们还可以分更多层，以此来进一步优化我们的空间消耗。

例如，在 \(n\leq 10^6\)，\(m\leq 2\times 10^6\) 时，如果分四层，则空间消耗仅需 \(360\texttt{MB}\)。代码如下：

const int MAXN = 1e6, MAXM = 2e6;
const int FULL3 = (1 << 3) - 1;
const int FULL6 = (1 << 6) - 1;

int b1[MAXN + 5][MAXN / (1 << 15) + 5], cnt_b1;
int b2[MAXM + 5][1 << 3], cnt_b2;
int b3[MAXM + 5][1 << 3], cnt_b3;
ull b4[MAXM + 5][1 << 3];

void add_edge(int u, int v) {
	if (!b1[u][v >> 15])
		b1[u][v >> 15] = ++cnt_b1;
	int id1 = b1[u][v >> 15];

	if (!b2[id1][(v >> 12) & FULL3])
		b2[id1][(v >> 12) & FULL3] = ++cnt_b2;
	int id2 = b2[id1][(v >> 12) & FULL3];

	if (!b3[id2][(v >> 9) & FULL3])
		b3[id2][(v >> 9) & FULL3] = ++cnt_b3;
	int id3 = b3[id2][(v >> 9) & FULL3];

	b4[id3][(v >> 6) & FULL3] |= 1ull << (v & FULL6);
}
bool have_edge(int u, int v) {
	if (!b1[u][v >> 15])
		return false;
	int id1 = b1[u][v >> 15];

	if (!b2[id1][(v >> 12) & FULL3])
		return false;
	int id2 = b2[id1][(v >> 12) & FULL3];

	if (!b3[id2][(v >> 9) & FULL3])
		return false;
	int id3 = b3[id2][(v >> 9) & FULL3];

	return b4[id3][(v >> 6) & FULL3] & (1ull << (v & FULL6));
}

之所以能不断向下分层，而且使空间消耗奇迹般地减小，它的核心是：不论怎么分，每层的事件都至多只有 \(m\) 个。

把这种思路推到极致，如果分出 \(\log n\) 层，则时间复杂度将回到 \(\mathcal{O}(\log n)\)，此时相当于给每个点 \(u\) 开了一个 \(\text{01-Trie}\)。

我们只需要记住，层数越多，时间上消耗越大，空间上消耗越小。本算法的精髓就是在它们之间找到符合实际需求的平衡点。