看某个ppt的时候看到了这个东西，就产生了一些兴趣。
这个东西似乎有点鸡肋，我做了这么久的题，没有见过一道是用支配树解决的。
不过这个算法真的很有趣。
现在我还没有学完。打打博客加深理解。
先推荐一篇很好的博客

什么是支配树？

现在我给你一个起点为$r$的有向图，你需要求各种有关必经点的问题。
先说一堆概念：
支配点：对于一个点$x$，如果$r$到$x$的所有路径上经过$y$，那么$y$支配$x$
最近支配点：对于一个点$x$，如果有一个点$y$满足$y$支配$x$，并且所有支配$x$的平凡支配点全都支配$y$，那么$y$就是$x$的最近必经点，记作$idom(x)$
平凡支配点就是除了$x$，之外的所有支配点。（其实网上的其它博客说$r$也不包括在内，不过我觉得这样方便理解）

定理1：对于任意的点，它的最近支配点都是唯一的。

证明：假设这个点是$x$，它有两个最近支配点分别为$y$和$z$
由定义得$z$支配$y$，并且$y$支配$z$。
因为$y̸=z$，所以矛盾

这个证明是不是特别简略……

既然每个点的最近支配点都是唯一的，那我们自然而然地想到可以建立一棵树。
对于点$x$，将$idom(x)$作为自己的父亲，方向为$idom(x)$到$x$。
这就是支配树。

性质？

对于一个点$x$，所有支配它的点都是它在支配树上的祖先。
所以说我们可以利用它这个奇妙的性质做各种各样有关必经点的事情。

知道了支配树的功能，现在我们的主要问题是，如何建立支配树。
建立支配树就需要更多的概念和性质……

更加详细的性质

首先，从$r$开始，建立一棵dfs树。
显然这个dfs树并不是支配树……
记录一下它们的dfs序，在后面的叙述中，我直接用dfs序来表示它们的编号。

一棵图中的边$(x,y)$有四种情况：树枝边（这里指的是dfs树），前向边（$x$是$y$的祖先），后向边（$x$是$y$的后代），横插边（显然$x>y$）。
接下来我们用几个符号来表示各种关系（这个一定要记住）：
$a\to b$表示$a$能直接通过一条边到达$b$
$a⇝b$表示$a$能通过某条路径到达$b$
$a\dot{\to }b$表示$a$能通过树枝边到达$b$
$a\stackrel{+}{\to }b$表示$a\dot{\to }b$并且$a̸=b$

引理1（路径引理）
对于两个点$v$和$w$，若$v\le w$，那么$v$到$w$的路径上必定经过他们的公共祖先（也就是$LCA(v,w)$及其所有祖先）

证明：如果$v$是$w$的祖先，显然成立。
因为横插边都是从大点去到小点，所以不可以通过横插边从$v$所在的子树到达$w$所在的子树。
所以只能通过后向边跳上公共祖先，然后从公共祖先通过前向边跳下来。

半支配点

对于$w̸=r$，都有一个半支配点$sdom(w)$
$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\}$
也就是说，从$sdom(w)$开始，存在一条从$sdom(w)$到$w$的路径，使得中间经过的所有点都比$w$大。
注意，半支配点并不一定是支配点，可能是支配点。

引理2：
对于任意$w̸=r$，满足$idom(w)\stackrel{+}{\to }w$
（证明显然：如果不是这样，它就可以直接通过树枝边来到达$w$了，与定义矛盾）

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

证明：首先，$f{a}_w$是$sdom(w)$的一个候选，因为中间没有任何的点落脚。
所以$sdom(w)\le f{a}_w$
根据路径引理，如果$sdom(w)$在另一棵子树，那么必定经过他们的公共祖先，公共祖先小于$x$，与定义矛盾

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

证明：如果不是这样，那么存在路径$r⇝sdom(w)⇝w$，
$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(v)\stackrel{+}{\to }v\dot{\to }idom(w)\stackrel{+}{\to }w$
$idom(w)\dot{\to }idom(v)\stackrel{+}{\to }v\dot{\to }w$
也就是$idom(v)\stackrel{+}{\to }v$要么被$idom(w)\stackrel{+}{\to }w$包含，要么不相交。（这样说不严谨，因为端点可能会重合）

证明：如果不是这样，那么$idom(v)\stackrel{+}{\to }idom(w)\stackrel{+}{\to }v\stackrel{+}{\to }w$
存在$r\dot{\to }idom(v)⇝v\stackrel{+}{\to }w$。（$idom(w)$是$idom(v)$的真后代，不支配$v$。所以可以绕过$idom(w)$到达$w$）
与$idom$的定义矛盾。

这后面的会难一些，不对，是难很多。
揭示了$idom$和$sdom$的关系
定理2：
对于任意$w̸=r$，如果所有满足$sdom(w)\stackrel{+}{\to }u\dot{\to }w$的$u$也满足$sdom(w)\le sdom(u)$，则$idom(w)=sdom(w)$
画一下就是：
$sdom(w)\dot{\to }sdom(u)\stackrel{+}{\to }u\dot{\to }w$

证明：由定理4得$idom(w)\dot{\to }sdom(w)$，所以如果我们想要证明$idom(w)=sdom(w)$，就只需要证明$sdom(w)$支配$w$即可。
对于任意从$r$到$w$的路径，取最后一个小于$sdom(w)$的点$x$。
假设$y$是$x$的后继
由于$x$是最后一个小于$sdom(w)$的点，所以$sdom(w)\le y$。
由$sdom$的定义得，必定存在$y$满足$sdom(w)\dot{\to }y\dot{\to }w$（否则$x$就是$sdom(w)$）
取最小的$y$，假设$y$不是$sdom(w)$
由条件得$sdom(w)\le sdom(y)$，由于$x<sdom(w)$，所以$x̸=sdom(y)$
所以存在$x\stackrel{+}{\to }t\stackrel{+}{\to }y$，由于$x$是最后一个小于$sdom(w)$的点，所以$sdom(w)\dot{\to }t\dot{\to }w$
在前面已经说过$y$是最小的，所以矛盾
因此$y$就是$sdom(w)$
所以任意路径经过$sdom(w)$，因此$sdom(w)$支配$w$。
即$idom(w)=sdom(w)$

这是前面说过的参考博客的证明，但是我感觉这种证明有点问题。
于是自己用另一种方法证明了一遍：

证明：我们同样是证明$sdom(w)$支配$w$
反证法，假设存在路径绕过$sdom(w)$到达$w$
这条路径必定可以看作，从$r$绕过$sdom(w)$到达点$x$（满足$sdom(w)\stackrel{+}{\to }x\dot{\to }w$），然后直接到$w$。
1、当从某个比$x$大的点来到$x$时，由于$sdom(w)\le sdom(x)$，所以$sdom(w)\dot{\to }sdom(x)$，不可能直接通过树枝边从$r$到达$sdom(x)$，不存在这样的路径。
2、当从某个比$x$小的点来到$w$时，
（1）如果从树枝边走来：
如果$x$是$sdom(w)$的儿子，那么$sdom(x)=sdom(w)$，所以不能到达。
用归纳证明的思想，可得后面的点都不能到达。所以这个点不能在$sdom(w)$和$w$之间的路径上。
（2）如果从$sdom(w)$的子树外走来
这个点显然可以作为$sdom(x)$的取值，但是$sdom(w)\le sdom(x)$，矛盾
综上，这种路径不存在。

可能还是有点不严谨，不过理解一下就好。

定理3：
对于任意$w̸=r$，设$u$为满足$sdom(w)\stackrel{+}{\to }u\dot{\to }w$的$sdom(u)$最小的$u$，如果sdom(u)$\le sdom(w)$，那么$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(w)\dot{\to }idom(u)\dot{\to }sdom(w)\stackrel{+}{\to }u\dot{\to }w$
所以，我们要证明$idom(w)=idom(u)$，只需要证明$idom(u)$支配$w$即可。
类似于之前的思路：
假设有某一条路径绕过$idom(u)$到达$w$
1、从大于$w$点到达$w$
如果这样，存在一个点$x$，满足$sdom(w)$的定义（不一定最小）。
如果$x\stackrel{+}{\to }u$，
因为$idom(u)$支配$u$，而又存在$r⇝x\stackrel{+}{\to }u$，所以$idom(u)$支配$x$。
所以不存在某种绕过$sdom(w)$到达$x$的方案。
如果$u\dot{\to }x$，那么继续考虑能不能到达$x$（像个递归的过程），最终总会到$x\stackrel{+}{\to }u$的状况，因此也是不存在的。
2、从小于$w$点到达$w$
（1）从树枝边走来
类似于之前的情况，如果存在这样的路径，必定能从起点绕过$idom(u)$到达$u$和$w$之间的某个点。（前面已经证明过绕$idom(u)$到达$idom(u)$和$u$之间的点不存在）
但是连$sdom(u)$最小的$u$都不成立，那其他的点也不可能了。
（2）从$idom(u)$外走来
如果可以这么走，那它就应该是$sdom(w)$，矛盾。
综上所述，不存在这样的路径

推论1
对于任意$r̸=w$，如果有满足$sdom(w)\stackrel{+}{\to }u\dot{\to }w$且$sdom(u)$最小的$u$，那么
$$idom(w)=\{\begin{array}{rlrl}& sdom(w)& (sdom(u)=sdom(w))& \\ & idom(u)& (sdom(u)<sdom(w))& \end{array}$$
这个东西是通过上面的定理2和定理3推过来的。但是在这里，我们发现$sdom(u)\le sdom(w)$的，为什么呢？
我感觉博客中简略的证法好像有问题，所以我自己想了一下：

证明：如果存在某种情况使得$sdom(u)>sdom(w)$
画图就是这样：$sdom(w)\stackrel{+}{\to }sdom(u)\stackrel{+}{\to }u\dot{\to }w$
显然$sdom(sdom(u))<sdom(u)$，所以此时的$sdom(u)$应该是$u$。
我们已经要求过$sdom(u)$最小，所以矛盾。
因此$sdom(u)\le sdom(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$，显然$sdom(w)\le x$。现在要证明$x\le sdom(w)$
如果$sdom(w)$到$w$中只经过一条边，显然$(sdom(w),w)\in E$且$sdom(w)<w$，所以$x\le sdom(w)$
如果不只经过一条边，设这条路径上的最后一个点为$last$。在$sdom(w)$和$last$之间找到一个最小的点$p$，显然$sdom(w)$到$p$上经过的点都比$p$大，所以$sdom(p)\le sdom(w)$。
同时$sdom(p)$满足等式右边的条件，满足$p\dot{\to }last$，$(last,w)\in E$。
所以$sdom(p)$是$x$的一个候选，所以$x\le sdom(p)\le sdom(w)$，所以$x\le sdom(w)$
综上，$x\le sdom(w)$。
所以$sdom(w)=x$

Lengauer-Tarjan算法

前面推的东西都是为这个算法铺垫的。这个算法用到定理4和推论1。
先说说步骤：
1、dfs一遍，求出$dfn$。
2、按照$dfn$倒着求出$sdom$。
3、确定$idom=sdom$的$idom$，其它的暂时不理它。
4、按照$dfn$顺着找没有计算的$idom$，计算。

第1步不说。
第2步和第3步可以放在一起来写。
我们要用一个数据结构来维护一个森林，每个点到根的路径上最小的$sdom$。这个数据结构可以用并查集。我们记作$x$的这个东西为$eval(x)$
看看定理4的式子：$sdom(w)=min(\{v|(v,w)\in E,v<w\}\cup \{sdom(u)|u>w,\exists (v,w)\in E,u\dot{\to }v\})$
由于我们是倒过来做的，所以对于点$w$来说，若它的前驱$v>w$，那么上式右边的$u$取$eval(v)$是最合适的。如果前驱$v<w$，它们没有处理过，可以把$sdom$的初值设为它们自己、
通过定理4可以求出所有点的$sdom$。
接下来将它挂在它的$sdom$上。每做完一个子树之后，在并查集上将子树和父亲合并，然后处理留在父亲上的$sdom$，也就是通过引理1来计算$idom$。具体来说，如果父亲是$x$，挂在父亲上的点$w$，它们满足$sdom(w)=x$，如果$sdom(eval(w))=x$，那么$idom(w)=sdom(w)=x$，否则$idom(w)=idom(eval(w))$，这个东西先不要求出来，可以在实现的时候记作$idom(w)=eval(w)$。
最后就是第4步，按照$dfn$从小到大枚举，如果$idom(w)=sdom(w)$，说明$idom(w)$已经被处理过，不理它；否则，$idom(x)=idom(idom(x))$。
这样就求出所有点的$idom(x)$了。

清点一下要维护的东西：
$idom$和$sdom$数组
并查集维护$eval$
每个点的前驱$pred$
将点挂在$sdom$用的数组（链表）$buc$
以及一些零零散散的东西。

这个算法的时间复杂度实际上是$O(n\lg n)$的，我受到了那篇博客的影响，知道并查集能被卡成$\lg$级别。当然这种情况大多数是不会见到的，毕竟没几个人来卡你的并查集，就算卡，凭借着并查集的优秀常数也不会多慢。
姑且认为是$O(n\alpha (n))$的，几乎都是这样了。

代码

using namespace std;
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 200000
#define M 300000
int n,m;
struct EDGE{
    int to;
    EDGE *las;
} e[M+1],pe[M+1],te[M+1],be[M+1];
//这四个东西都用链表来存。e表示图边，pe表示反向边（pred），te表示建出来的支配树，be表示buc
int ne,pne,tne,bne;
EDGE *last[N+1],*plast[N+1],*tlast[N+1],*blast[N+1];
int dfn[N+1],nowdfn,ver[N+1]; //dfn为dfs的时间戳，ver为dfs序。
int idom[N+1],sdom[N+1];
int fa[N+1];
void init(int x){//初始化，求出dfn，ver
    dfn[x]=++nowdfn,ver[nowdfn]=x;
    sdom[x]=x;
    for (EDGE *ei=last[x];ei;ei=ei->las)
        if (!dfn[ei->to]){
            fa[ei->to]=x;
            init(ei->to);
    	}
}
int top[N+1],eval[N+1];//这些就是并查集维护的东西
inline int sdom_min(int a,int b){return dfn[sdom[a]]<dfn[sdom[b]]?a:b;}
inline int dfn_min(int a,int b){return dfn[a]<dfn[b]?a:b;}
void gettop(int x){
    if (top[x]==x)
        return;
    gettop(top[x]);
    eval[x]=sdom_min(eval[x],eval[top[x]]);
    top[x]=top[top[x]];
}
int siz[N+1];//最后的答案（洛谷的模板题输出支配树中每个点的子树大小）
void get_siz(int x){
    siz[x]=1;
    for (EDGE *ei=tlast[x];ei;ei=ei->las)
        get_siz(ei->to),siz[x]+=siz[ei->to];
}
int main(){
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;++i){
        int u,v;
        scanf("%d%d",&u,&v);
        e[++ne]={v,last[u]};
        last[u]=e+ne;
        pe[++pne]={u,plast[v]};
        plast[v]=pe+pne;
    }
    init(1);
     for (int i=1;i<=n;++i)
        top[i]=eval[i]=i;
    for (int i=n;i>=1;--i){
        int x=ver[i],y=fa[x];
        for (EDGE *ei=plast[x];ei;ei=ei->las)
            gettop(ei->to),sdom[x]=dfn_min(sdom[x],sdom[eval[ei->to]]);//枚举前缀计算sdom
        be[++bne]={x,blast[sdom[x]]};//将x挂到sdom[x]上
        blast[sdom[x]]=be+bne;
        if (y)
            for (top[x]=y;blast[y];blast[y]=blast[y]->las){//将自己的子树和父亲合并；清空挂在父亲上的点，用来求idom   	
                int v=blast[y]->to;
                gettop(v);
                if (sdom[eval[v]]==sdom[v])
                    idom[v]=sdom[v];
                else
                    idom[v]=eval[v];
            }
    }
    for (int i=1,x=ver[i];i<=n;++i,x=ver[i])//将没有计算完idom的点计算好
        if (idom[x]!=sdom[x])
            idom[x]=idom[idom[x]];
    for (int i=2;i<=n;++i){
    	te[++tne]={i,tlast[idom[i]]};
    	tlast[idom[i]]=te+tne;
    }
    get_siz(1);
    for (int i=1;i<=n;++i)
        printf("%d ",siz[i]);
    return 0;
}