【学习笔记】支配树

【前言】

• 本文为博主的转载，由于博主看到的文章同样是转载的，无法注明原文出处。
• 博主在原文的基础上修改了格式、措辞和一些小错误，并适当添加了一些自己的理解。

【支配树简介】

• 对于一个单源有向图上的每个点$w$，都存在点$d$满足去掉$d$之后起点无法到达$w$，我们称作$d$支配$w$，$d$是$w$的一个支配点。

• 支配$w$的点可以有多个，但是至少会有一个。显然，对于起点以外的点，它们都有两个平凡的支配点，一个是自己，一个是起点。

• 在支配$w$的点中，如果一个支配点$i̸=w$满足$i$被$w$剩下的所有支配点支配，则这个$i$称作$w$的最近支配点 $(immediatedominator)$ ，记作$idom(w)$。

• 定理 $1$ ：我们把图的起点称作$r$，除$r$以外每个点均存在唯一的$idom$。

  证明： 如果$a$支配$b$且$b$支配$c$，则$a$一定支配$c$，因为到达$c$的路径都经过了$b$所以必须经过$a$。如果$b$支配$c$且$a$支配$c$，则$a$支配$b$（或者$b$支配$a$），否则存在从$r$到$b$再到$c$的路径绕过$a$，与$a$支配$c$矛盾。这就意味着支配定义了点$w$的支配点集合上的一个全序关系，所以一定可以找到一个“最小”的元素使得所有元素都支配它。

• 于是，$idom(w)\to w(w̸=r)$ 的边，就能得到一棵树，其中每个点支配它子树中的所有点，它就是支配树。

• 下文介绍了构建支配树的 $Lengauer-Tarjan$ 算法，其时间复杂度为 $O(NLogN+M)$ ，空间复杂度为 $O(N+M)$ 。

• 为了能够求出支配树，我们下面来推导一下需要用到的一些定理。

【定理推导】

• 首先，我们会使用一棵 $DFS$ 树来帮助我们计算。从起点出发进行 $DFS$ 就可以得到一棵 $DFS$ 树。

• 原图中的边被分为了以下两类：在 $DFS$ 树上出现的边称作树边，剩下的边称为非树边。非树边也可以分为几类：从祖先指向后代（前向边），从后代指向祖先（后向边），从一棵子树內指向另一棵子树内（横叉边）。树边是我们非常熟悉的，所以着重考虑一下非树边。

• 我们按照 $DFS$ 到的先后顺序给点从小到大编号（在下面的内容中我们通过这个比较两个节点），那么前向边总是由编号小的指向编号大的，后向边总是由大指向小，横叉边也总是由大指向小。现在在 $DFS$ 树上我们要证明一些重要的引理：

• 引理 $1$ （路径引理）：如果两个点$v,w$满足$v\le w$，那么任意$v$到$w$的路径经过$v,w$的公共祖先。（注意这里不是说 $LCA$ ）

  证明： 如果$v,w$其中一个是另一个的祖先显然成立。否则删掉起点到 $LCA$ 路径上的所有点（这些点是$v,w$的公共祖先），那么$v$和$w$在两棵子树内，并且因为公共祖先被删去，无法通过后向边到达子树外面，前向边也无法跨越子树，而横叉边只能从大到小，所以从$v$出发不能离开这颗子树到达$w$。所以如果本来$v$能够到达$w$，就说明这些路径必须经过$v,w$的公共祖先。

• 在继续之前，我们先约定一些记号：

$V$代表图的点集，$E$代表图的边集。$a\to b$代表从点$a$直接经过一条边到达点$b$，$a⇝b$代表从点$a$经过某条路径到达点$b$，$a\dot{\to }b$代表从点$a$经过 $DFS$ 树上的树边到达点$b$（$a$是$b$在 $DFS$ 树上的祖先），$a\stackrel{+}{\to }b$代表$a\dot{\to }b$且$a̸=b$。

• 定义：半支配点 $(semi-dominator)$ ：对于$w̸=r$，它的半支配点定义为 $sdom(w)=\min \{v|\exists (v_0,v_1,\cdots ,v_{k-1},v_k),v_0=v,v_k=w,\forall 1\le i\le k-1,v_i>w\}$

  这个定义可以理解为从$v$出发，可以绕过小于$w$的所有点到达$w$（只能以大于 $w$ 的点作为落脚点）的最小的 $v$ 。

  注意这只是个辅助定义，并不是真正的支配点。

• 引理 $2$ ：对于任意$w̸=r$，有$idom(w)\stackrel{+}{\to }w$。

  证明： 如果不是这样的话就可以直接通过树边不经过$idom(w)$就到达$w$了，与$idom$定义矛盾。

• 引理 $3$ ：对于任意$w̸=r$，有$sdom(w)\stackrel{+}{\to }w$。

  证明： 对于$w$在 $DFS$ 树上的父亲$f{a}_w$，$f{a}_w\to w$这条路径只有两个点，所以满足$sdom$定义中的条件，于是它是$sdom(w)$的一个候选。所以$sdom(w)\le f{a}_w$。在这里我们就可以使用路径引理证明$sdom(w)$不可能在另一棵子树，因为如果是那样的话就会经过$sdom(w)$和$w$的一个公共祖先，公共祖先的编号一定小于$w$，所以不可行。于是$sdom(w)$就是$w$的真祖先。

• 引理 $4$ ：对于任意$w̸=r$，有$idom(w)\dot{\to }sdom(w)$。

  证明： 如果不是这样的话，按照$sdom$的定义，就会有一条路径是$r\dot{\to }sdom(w)⇝w$不经过$idom(w)$了，与$idom$定义矛盾。

• 引理 $5$ ：对于满足$v\dot{\to }w$的点$v,w$，$v\dot{\to }idom(w)$或$idom(w)\dot{\to }idom(v)$。

  直观地理解就是$idom(w)$到$w$的路径两两之间边不相交或者存在完全包含关系。

  证明： 如果不是这样的话，就说明$idom(v)\stackrel{+}{\to }idom(w)\stackrel{+}{\to }v\stackrel{+}{\to }w$，那么存在路径$r\dot{\to }idom(v)⇝v\stackrel{+}{\to }$不经过$idom(w)$到达了$w$（因为$idom(w)$是$idom(v)$的真后代，一定不支配$v$，所以存在绕过$idom(w)$到达$v$的路径），矛盾。

• 上面这 $5$ 条引理都比较简单，但是非常重要的性质。接下来我们要证明几个定理，它们揭示了$idom$与$sdom$的关系。证明会比上面的复杂一点。

• 定理 $2$ ：对于任意$w̸=r$，如果所有满足$sdom(w)\stackrel{+}{\to }u\dot{\to }w$的$u$也满足$sdom(u)\ge sdom(w)$，那么$idom(w)=sdom(w)$。

  证明： 条件可以写为 $sdom(w)\dot{\to }sdom(u)\stackrel{+}{\to }u\dot{\to }w$。

  由上面的引理 $4$ 知道$idom(w)\dot{\to }sdom(w)$，所以只要证明$sdom(w)$支配$w$就可以保证是最近支配点了。对任意$r$到$w$的路径，取上面最后一个编号小于$sdom(w)$的$x$（如果$sdom$就是$r$的话显然定理成立），它必然有个后继$y$满足$sdom(w)\dot{\to }y\dot{\to }w$（否则$x$会变成$sdom(w)$），我们取最小的那个$y$。同时，如果$y$不是$sdom(w)$，根据条件，$sdom(y)\ge sdom(w)$，所以$x$不可能是$sdom(y)$，这就意味着$x$到$y$的路径上一定有一个$v$满足$x\stackrel{+}{\to }v\stackrel{+}{\to }y$，因为$x$是小于$sdom(w)$的最后一个，所以$v$也满足$sdom(w)\dot{\to }v\dot{\to }w$，但是我们取的$y$已经是最小的一个了，矛盾。于是$y$只能是$sdom(w)$，那么我们就证明了对于任意路径都要经过$sdom(w)$，所以$sdom(w)$就是$idom(w)$。

• 定理 $3$ ：对于任意$w̸=r$，令$u$为所有满足$sdom(w)\stackrel{+}{\to }u\dot{\to }w$的$u$中$sdom(u)$最小的一个，那么$sdom(u)\le sdom(w)\Rightarrow idom(w)=idom(u)$。

  证明： 条件可以写为$sdom(u)\dot{\to }sdom(w)\stackrel{+}{\to }u\dot{\to }w$。

  由引理 $5$ ，有$idom(w)\dot{\to }idom(u)$或$u\dot{\to }idom(w)$，由引理 $4$ 排除后面这种。所以只要证明$idom(u)$支配$w$即可。类似定理 $2$ 的证明，我们取任意$r$到$w$路径上最后一个小于$idom(u)$的$x$（如果$idom(u)$是$r$的话显然定理成立），路径上必然有个后继$y$满足$idom(u)\dot{\to }y\dot{\to }w$（否则$x$会变成$sdom(w)$），我们取最小的一个$y$。类似上面的证明，我们知道$x$到$y$的路径上不能有点$v$满足$idom(u)\dot{\to }v\stackrel{+}{\to }y$，于是$x$成为$sdom(y)$的候选，所以$sdom(y)\le x$。那么根据条件我们也知道了$y$不能是$sdom(w)$的真后代，于是$y$满足$idom(u)\dot{\to }y\dot{\to }sdom(w)$。但是我们注意到因为$sdom(y)\le x$，存在一条路径$r\dot{\to }sdom(y)⇝y\dot{\to }u$，如果$y$不是$idom(u)$的话这就是一条绕过$idom(u)$的到$u$的路径，矛盾，所以$y$必定是$idom(u)$。所以任意到$w$的路径都经过$idom(u)$，所以$idom(w)=idom(u)$ 。

• 完成了上面两个定理的证明，我们就能够通过$sdom$求出$idom$了。

• 推论 $1$ ：对于$w̸=r$，令$u$为所有满足$sdom(w)\stackrel{+}{\to }u\dot{\to }w$的$u$中$sdom(u)$最小的一个，有

  $$idom(w)=\{\begin{array}{rlrl}& sdom(w)& (sdom(u)=sdom(w))& \\ & idom(u)& (sdom(u)<sdom(w))& \end{array}$$

  推论 $1$ 可以通过定理 $2$ 和定理 $3$ 可以直接得到。这里一定有$sdom(u)\le sdom(w)$，因为$w$也是$u$的候选。

• 接下来我们的问题是，直接通过定义计算$sdom$很低效，我们需要更加高效的方法，所以我们证明下面这个定理：

• 定理 $4$ ：对于任意$w̸=r$

  $sdom(w)=min(v|(v,w)\in E,v<w\cup sdom(u)|u>w,\exists (v,w)\in E,u\dot{\to }v)$

  证明： 令右侧为$x$，显然右侧的点集中都存在路径绕过$w$之前的点，所以$sdom(w)\le x$。然后我们考虑$sdom(w)$到$w$的绕过$w$之前的点的路径，如果只有一条边，那么必定满足$(sdom(w),w)\in E$且$sdom(w)<w$，所以此时$x\le sdom(w)$；如果多于一条边，令路径上$w$的上一个点为$last$，我们取路径上除两端外满足$p\dot{\to }last$的最小的$p$（一定能取得这样的$p$，因为$last$是$p$的候选）。因为这个$p$是最小的，所以$sdom(w)$到$p$的路径必定绕过了$p$之前的所有点，于是$sdom(w)$是$sdom(p)$的候选，所以$sdom(p)\le sdom(w)$。同时，$sdom(p)$还满足右侧的条件（$p$在绕过$w$之前的点的路径上，于是$p>w$，并且$p\dot{\to }last$，同时$last$直接连到了$w$），所以$sdom(p)$是$x$的候选，$x\le sdom(p)$。所以$x\le sdom(p)\le sdom(w)$，$x\le sdom(w)$。综上，$sdom(w)\le x$且$x\le sdom(w)$，所以$x=sdom(w)$。

• 现在最困难的步骤已经完成了，我们得到了$sdom$的一个替代定义，而且这个定义里面的形式要简单得多。这种基本的树上操作我们是非常熟悉的，所以没有什么好担心的了。接下来就可以给出我们需要的算法了。

【构造流程】

• 以下是算法的简要流程

  $1$ 、初始化、跑一遍 $DFS$ 得到 $DFS$ 树和标号
  $2$ 、按标号从大到小求出$sdom$（利用定理 $4$ ）
  $3$ 、通过推论 $1$ 求出所有能确定的$idom$，剩下的点记录下和哪个点的$idom$是相同的
  $4$ 、按照标号从小到大再跑一次，得到所有点的$idom$

• 以下是算法的具体实现细节

• 大致要维护的东西：
  $p(x)$ 标号为$x$的点$u$
  $b(u)$ 有边直接连到$u$的点集
  $c(u)$ $sdom$为点$u$的点集
  $father(u)$ $u$在 $DFS$ 树上的父亲$f{a}_u$
  以及$idom$和$sdom$数组

• 这里多说一句，由于我们上文的推导中我们经常会用一个点的 $DFS$ 序来代替一个点来论述，我们有时会无法分清一个数组的下标和数值究竟代表一个点 $x$ 在原图中的标号还是它的 $DFS$ 序。

• 为了统一，我们不妨规定数组的下标一律使用点在原图中的标号，除了计算过程中的$idom$和$sdom$数组记录点的 $DFS$ 序标号以外，其余数组一律记录点在原图中的标号。

• 算法的第 $1$ 步没什么特别的，规规矩矩地 $DFS$ 一次即可，同时初始化$sdom$为自己（这是为了实现方便）。

• 第 $2$ 、第 $3$ 步可以一起做。通过一个辅助数据结构维护一个森林，支持加入一条边$(link(u,v))$ 和查询点到根路径上的点的$sdom$的最小值对应的点 $(home(u))$ 。那么我们求每个点的$sdom$只需要对它的所有直接前驱$home$一次，求得前驱中的$sdom$最小值即可。因为定理 $4$ 中的第一类点编号比它小，它们还没有处理过，所以自己就是根，$home$就能取得它们的值；对于第二类点，$home$查询的就是满足$u\dot{\to }v$的$u$的$sdom(u)$的最小值。所以这么做和定理 $4$ 是一致的。

• 然后把该点加入它的$sdom$的$c$里，连上它与父亲的边。现在它父亲到它的这棵子树中已经处理完了，所以可以对父亲的$c$里的每个点求一次$idom$并且清空$c$。对于$c$里的每个点$v$，求出$home(v)$，此时$father(w)\stackrel{+}{\to }home(v)\dot{\to }v$，于是直接按照推论 $1$ ，如果$sdom(home(v))=sdom(v)$，则$idom(v)=sdom(v)=father(w)$；否则可以记下$idom(v)=idom(home(v))$，实现时我们可以写成$idom(v)=home(v)$，留到第 $4$ 步处理。

• 最后从小到大扫一遍完成第 $4$ 步，对于每个$u$，如果$idom(u)=sdom(u)$的话，就已经是第 $3$ 步求出的正确的$idom$了，否则就证明这是第 $3$ 步留下的待处理点，令$idom(u)=idom(idom(u))$即可。

• 至于这个辅助数据结构，我们可以选择并查集。不过因为我们需要查询到根路径上的信息，所以不方便按秩合并，但是我们仍然可以路径压缩，压缩时保留路径上的最值就可以了。这样做的话，最终的时间复杂度是$O(NLogN+M)$。

【代码】

• 模板题【HDU4694】

#include
using namespace std;
const int MAXN = 50005;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, m, timer, root, dfn[MAXN], p[MAXN], father[MAXN];
int idom[MAXN], sdom[MAXN], f[MAXN], home[MAXN];
long long ans[MAXN]; vector <int> a[MAXN], b[MAXN], c[MAXN];
void dfs(int pos) {
	dfn[pos] = ++timer, p[timer] = pos;
	for (unsigned i = 0; i < a[pos].size(); i++)
		if (dfn[a[pos][i]] == 0) {
			father[a[pos][i]] = pos;
			dfs(a[pos][i]);
		}
}
int F(int x) {
	if (f[x] == x) return x;
	int tmp = f[x];
	f[x] = F(f[x]);
	if (sdom[home[tmp]] < sdom[home[x]]) home[x] = home[tmp];
	return f[x];
}
int gethome(int x) {
	F(x);
	return home[x];
}
void work(int pos, long long sum) {
	ans[pos] = sum;
	for (unsigned i = 0; i < a[pos].size(); i++)
		work(a[pos][i], sum + a[pos][i]);
}
int main() {
	while (scanf("%d%d", &n, &m) != EOF) {
		for (int i = 1; i <= n; i++) {
			a[i].clear();
			b[i].clear();
			c[i].clear();
		}
		for (int i = 1; i <= m; i++) {
			int x, y; read(x), read(y);
			a[x].push_back(y);
			b[y].push_back(x);
		}
		memset(dfn, 0, sizeof(dfn));
		timer = 0; dfs(root = n);
		for (int i = 1; i <= timer; i++) {
			sdom[p[i]] = i;
			idom[p[i]] = 0;
			f[p[i]] = home[p[i]] = p[i];
		}
		for (int i = timer; i >= 2; i--) {
			int tmp = p[i];
			for (unsigned j = 0; j < b[tmp].size(); j++)
				if (dfn[b[tmp][j]]) chkmin(sdom[tmp], sdom[gethome(b[tmp][j])]);
			c[sdom[tmp]].push_back(tmp);
			f[tmp] = father[tmp];
			tmp = dfn[father[tmp]];
			for (unsigned j = 0; j < c[tmp].size(); j++) {
				int tnp = gethome(c[tmp][j]);
				if (sdom[tnp] == tmp) idom[c[tmp][j]] = tmp;
				else idom[c[tmp][j]] = dfn[tnp];
			}
			c[tmp].clear();
		}
		for (int i = 1; i <= n; i++)
			a[i].clear();
		for (int i = 2; i <= timer; i++) {
			int tmp = p[i];
			if (sdom[tmp] == idom[tmp]) idom[tmp] = p[idom[tmp]];
			else idom[tmp] = idom[p[idom[tmp]]];
			sdom[tmp] = p[sdom[tmp]];
			a[idom[tmp]].push_back(tmp);
		}
		memset(ans, 0, sizeof(ans));
		work(root, root);
		for (int i = 1; i <= n; i++) {
			write(ans[i]);
			if (i == n) putchar('\n');
			else putchar(' ');
		}
	}
	return 0;
}