【学习笔记】支配树

【前言】

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

【支配树简介】

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

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

• 在支配 $w$ 的点中，如果一个支配点 $i \neq w$ 满足 $i$ 被 $w$ 剩下的所有支配点支配，则这个 $i$ 称作 $w$ 的最近支配点 $(immediate\ dominator)$ ，记作 $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\ne r)$ 的边，就能得到一棵树，其中每个点支配它子树中的所有点，它就是支配树。

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

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

【定理推导】

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

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

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

• 引理 $1$ （路径引理）：如果两个点 $v,w$ 满足 $v \leq 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 \leadsto b$ 代表从点 $a$ 经过某条路径到达点 $b$ ， $a \dot \to b$ 代表从点 $a$ 经过 $DFS$ 树上的树边到达点 $b$ （ $a$ 是 $b$ 在 $DFS$ 树上的祖先）， $a \overset{+}{\to} b$ 代表 $a \dot \to b$ 且 $a \neq b$ 。

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

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

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

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

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

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

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

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

  证明：如果不是这样的话，按照 $sdom$ 的定义，就会有一条路径是 $r \dot \to sdom(w) \leadsto 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) \overset{+}{\to} idom(w) \overset{+}{\to} v \overset{+}{\to} w$ ，那么存在路径 $r \dot \to idom(v) \leadsto v \overset{+}{\to}$ 不经过 $idom(w)$ 到达了 $w$ （因为 $idom(w)$ 是 $idom(v)$ 的真后代，一定不支配 $v$ ，所以存在绕过 $idom(w)$ 到达 $v$ 的路径），矛盾。

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

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

  证明：条件可以写为 $sdom(w) \dot \to sdom(u) \overset{+}{\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) \geq sdom(w)$ ，所以 $x$ 不可能是 $sdom(y)$ ，这就意味着 $x$ 到 $y$ 的路径上一定有一个 $v$ 满足 $x \overset{+}{\to} v \overset{+}{\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 \neq r$ ，令 $u$ 为所有满足 $sdom(w) \overset{+}{\to} u \dot \to w$ 的 $u$ 中 $sdom(u)$ 最小的一个，那么 $sdom(u) \leq sdom(w) \Rightarrow idom(w) = idom(u)$ 。

  证明：条件可以写为 $sdom(u) \dot \to sdom(w) \overset{+}{\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 \overset{+}{\to} y$ ，于是 $x$ 成为 $sdom(y)$ 的候选，所以 $sdom(y) \leq x$ 。那么根据条件我们也知道了 $y$ 不能是 $sdom(w)$ 的真后代，于是 $y$ 满足 $idom(u) \dot \to y \dot \to sdom(w)$ 。但是我们注意到因为 $sdom(y) \leq x$ ，存在一条路径 $r \dot \to sdom(y) \leadsto y \dot \to u$ ，如果 $y$ 不是 $idom(u)$ 的话这就是一条绕过 $idom(u)$ 的到 $u$ 的路径，矛盾，所以 $y$ 必定是 $idom(u)$ 。所以任意到 $w$ 的路径都经过 $idom(u)$ ，所以 $idom(w)=idom(u)$ 。

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

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

  　　　　

  $$idom(w) = \left \{ \begin{aligned}& sdom(w)&(sdom(u)=sdom(w))&\\ &idom(u)&(sdom(u)<sdom(w))&\end{aligned} \right .$$

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

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

• 定理 $4$ ：对于任意 $w \neq 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) \leq x$ 。然后我们考虑 $sdom(w)$ 到 $w$ 的绕过 $w$ 之前的点的路径，如果只有一条边，那么必定满足 $(sdom(w),w) \in E$ 且 $sdom(w)<w$ ，所以此时 $x \leq sdom(w)$ ；如果多于一条边，令路径上 $w$ 的上一个点为 $last$ ，我们取路径上除两端外满足 $p \dot \to last$ 的最小的 $p$ （一定能取得这样的 $p$ ，因为 $last$ 是 $p$ 的候选）。因为这个 $p$ 是最小的，所以 $sdom(w)$ 到 $p$ 的路径必定绕过了 $p$ 之前的所有点，于是 $sdom(w)$ 是 $sdom(p)$ 的候选，所以 $sdom(p) \leq sdom(w)$ 。同时， $sdom(p)$ 还满足右侧的条件（ $p$ 在绕过 $w$ 之前的点的路径上，于是 $p>w$ ，并且 $p\dot \to last$ ，同时 $last$ 直接连到了 $w$ ），所以 $sdom(p)$ 是 $x$ 的候选， $x \leq sdom(p)$ 。所以 $x \leq sdom(p) \leq sdom(w)$ ， $x \leq sdom(w)$ 。综上， $sdom(w) \leq x$ 且 $x \leq 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$ 树上的父亲 $fa_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) \overset{+}{\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<bits/stdc++.h>

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];
          }
      }
      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;
}