支配树, Tarjan: 没错又是我

支配树 (Dominator Tree)

小贴士

由于一些原因, 支配树的中文条目和英文条目有一些出入, 不同的地方在中文词条是不能自恰的, 在这里提醒一下. 写这段文字时的版本是这个 (可能要复制链接访问而不是单击访问), 表格中 $5$ 号点没有 idom, 而按照左边的定义和英文条目来看, $5$ 号点的 idom 是 $2$, 也应该是 $2$.

一些定义

对于 $i$ 支配 $j$, 我们称 $i$ 是 $j$ 的必经点 (dom). 点 $i$ 的最近必经点 (idom) 必须满足除了它本身外不支配任何支配 $i$ 的节点. 记 $Fa_i$ 表示 $i$ 的 idom.

预处理

我们一开始从 $1$ 点开始 DFS, 记录每个点的 DFS 序 (DFN).

半必经点

定义 $y$ 为 $x$ 的半必经点 (semi), 需要存在 $y$ 到 $x$ 的一条路径上除了两端的 $x$, $y$, 剩下的任何点 $i$ 都满足 $DFN_i > DFN_x$. 我们记 $Sem_i$ 表示 $i$ 的 DFN 最小的 semi.

每个点 DFS 树上的父亲一定是它的一个 semi. 这样就可以推出 $Sem_i$ 一定是 $i$ 的一个祖先. 如果 $Sem_i$ 不是 $i$ 的父亲, 则它不是 $i$ 的祖先就是和 $i$ 无直系关系, 在另一棵更先搜索的子树上. 但是后者矛盾是因为如果存在一条路径从更先搜索的 $Sem_i$ 到 $i$, 那么 $i$ 也会比它的父亲更先搜索. 因此 $Sem_i$ 一定是祖先.

如果存在边 $x \rightarrow y$, 并且 $DFN_x < DFN_y$, 也就是说这是一条 DFS 树上的树边, $x$ 是 $y$ 的父亲, 则 $x$ 显然是 $y$ 的一个 semi.

如果 $DFN_x > DFN_y$, 那么这是横叉边或回边, 那么 $x$ 和它满足 $DFN_i > DFN_y$ 的祖先 $i$ 的 $Sem$ 也是 $y$ 的 semi.

设点 $i$ 是 $x$ 或它的祖先, 满足 $DFN_i > DFN_y$. 我们一定可以找到一条 $i$ 到 $x$ 的树边路径, 然后接上 $x \rightarrow y$ 变成 $i$ 到 $y$ 的路径, 根据定义能找到一条 $Sem_i$ 到 $i$ 的路径, 路径上其它点 $j$ 的 $DFN_j > DFN_i$. 拼接起来得到 $Sem_i$ 到 $y$ 的路径. 如果存在环, 那么我们只截取 $Sem_i$ 到 $y$ 的部分. 无论 $x \rightarrow y$ 是回边还是横叉边, 那么这路径中间的节点 $j$ 一定满足 $DFN_j > DFN_y$, 所以也是 $y$ 的 semi.

推论可以简化为: $x$, $y$ 的 LCA 的子树中的 $x$ 的祖先 (包含 $x$, 不包含 LCA) 的 $Sem$ 中 DFN 最小的一个.

求每个点 DFN 最小的 semi

为了求出每个点的 $Sem$, 我们按 DFS 序倒着枚举, 对每个点枚举它的所有入边, 如果是父亲, 那么就直接更新 $Sem$, 如果是横叉边或回边, 那么这个前驱点一直到 LCA 路径上所有点 (不包含 LCA) 的 $Sem$ 应该已经算完了, 并且 LCA 和它祖先的 $Sem$ 一定没算, 我们用并查集维护每个点到根的路径上, 所有确定 $Sem$ 值的点的 $Sem$ 最小值, 这样可以 $O(\log n)$ 对横叉边和回边进行查询.

求每个点的 idom

$Fa_i$ 一定是 $Sem_i$ 或它的祖先. 因为 $Fa_i$ 支配 $i$, 因此一定是 $i$ 的祖先.

当 $Sem_i$ 是 $i$ 在 DFS 树上的父亲的时候, 同为 $i$ 祖先的 $Fa_i$ 一定满足不是 $Sem_i$ 就是它的祖先的条件.

当 $Sem_i$ 不是 $i$ DFS 树上的父亲的时候, $Sem_i$ 可以找到包含非树边的路径到 $i$, 因此这时 $Fa_i$ 不可能是 $Sem_i$ 的后代.

我们找到 $Sem_i$ 到 $i$ 路径上, 除 $Sem_i$ 以外的所有点, $Sem$ 最小的是 $j$.

如果能够找到路径绕开 $Sem_i$, 则一定有 $DFN_{Sem_j} < DFN_{Sem_i}$. 所以如果 $Sem_j = Sem_i$ 的情况, 就有 $DFN_{Fa_i} \geq DFN_{Sem_i}$, 又因为 $Fa_i$ 是 $Sem_i$ 或它的祖先, 因此 $Fa_i = Sem_i$.

如果真的可以绕开, 那么支配 $i$ 的必要条件就是支配 $j$. 又因为 $Sem_j$ 一定是绕开 $Sem_i$ 的路径中, 离开树边最早的点, 因此支配 $j$ 也是支配 $i$ 的充分条件. 综上, $Fa_i = Fa_j$.

快速求 $j$

我们发现在求 $Sem$ 的时候我们也维护了树上一条链的 $DFN_{Sem_i}$ 最小的 $i$. 每次求 $x$ 的 $Sem$ 之前, 一定已经求出了 DFS 树上 $x$ 的所有后代的 $Sem$, 也就是说所有以 $x$ 作为 $Sem$ 的点都被求出来了. 这时遍历所有 $Sem_y = x$ 的 $y$, 用并查集查到的便是 $y$ 的 $j$ 值.

最后通过每个点的 $j$ 值按 DFN 从小到大扫一遍, 进行上面对 $Sem$ 的判断然后给 $Fa$ 赋值即可.

最后是代码, 这就是面向 vector 编程.

unsigned m, n;
unsigned A, B, C, D, t;
unsigned Cnt(0), Ans(0), Tmp(0);
struct Node;
struct Set {
  Set* Fa;
  Node* Val;
}S[200005], *Stack[200005], **STop(Stack);
struct Node {
  vector<Node*> E, IE, DFSSon, SemSon, Son;
  Node *Sem, *Fa, *J;
  unsigned DFN, Size;
  inline void DFSforDFN();
  inline void DFSforSize();
  inline char Les(Node* x) {return Sem->DFN < x->Sem->DFN;}
}N[200005], *Rk[200005];
inline Node* Find(Set* x) {
  while (x != x->Fa) *(++STop) = x, x = x->Fa;
  Node* Cur(x->Val);
  while (STop > Stack)
    Cur = ((*STop)->Val = (Cur->Les((*STop)->Val)) ? Cur : (*STop)->Val), (*(STop--))->Fa = x;
  return Cur;
}
inline void Node::DFSforDFN() {
  Rk[DFN = ++Cnt] = this;
  for (auto i:E) if(!(i->DFN)) DFSSon.push_back(i), i->DFSforDFN();
}
inline void Node::DFSforSize() {
  Size = 1;
  for (auto i:Son) i->DFSforSize(), Size += i->Size;
}
signed main() {
  n = RD(), m = RD(); 
  for (unsigned i(1); i <= m; ++i)
    A = RD(), B = RD(), N[A].E.push_back(N + B), N[B].IE.push_back(N + A); 
  N[1].DFSforDFN(), N[n + 1].DFN = 0x3f3f3f3f;
  for (unsigned i(1); i <= n; ++i) S[i] = {S + i, N + i};
  for (unsigned i(1); i <= n; ++i) N[i].J = N + i;
  for (unsigned i(n); i; --i) {
    Node* Cur(Rk[i]);
    for (auto j:Cur->SemSon) {
      Node* Get(Find(S + (j - N)));
      if(Get->Les(j->J)) j->J = Get;
    }
    Cur->Sem = N + n + 1;
    for (auto j:Cur->IE) {
      if(j->DFN < Cur->DFN) Cur->Sem = (Cur->Sem->DFN > j->DFN) ? j : Cur->Sem;
      else {
        Node* Get(Find(S + (j - N)));
        Cur->Sem = (Get->Les(Cur)) ? Get->Sem : Cur->Sem;
      }
    }
    Cur->Sem->SemSon.push_back(Cur);
    for (auto j:Cur->DFSSon) S[j - N].Fa = S + (Cur - N);
  }
  for (unsigned i(1); i <= n; ++i) {
    Node* Cur(Rk[i]);
    if(Cur->J->Sem == Cur->Sem) Cur->Fa = Cur->Sem;
    else Cur->Fa = Cur->J->Fa;
  }
  for (unsigned i(2); i <= n; ++i) N[i].Fa->Son.push_back(N + i);
  N[1].DFSforSize();
  for (unsigned i(1); i <= n; ++i) printf("%u ", N[i].Size); putchar(0x0A);
  return Wild_Donkey;
}