Tarjan（年早失修 漏洞百出）

Tarjan是谁

Tarjan's SCCs（有向图强连通分量）algorithm

给定⼀个有向图 $G$，若存在 $rt\in V$，满⾜从 $rt$ 出发能到达 $V$ 中的所有的点，则称 $G$ 是⼀个源点为 $rt$ 流图。

从 $rt$ 出发做 $DFS$。

符号表

• $fa[x]$：$x$ 节点的父亲节点

• $anc[x]$：$x$ 节点的祖先点集

• $son[x]$：搜索树中 $x$ 节点的儿子节点集

• $e[x]$：$\{y \ | \ (x \to y)\in E\}$

• $dfn[x]$：$x$ 节点的时间戳

• $sbt[x]$：$x$ 节点为根的子树点集

• $low[x]$：$x$ 节点的追溯值

$G$ 中的每条有向边 $x\to y$ 必然是以下四种之⼀：

• 枝：$x=fa[y]$

• 前：$x\in (anc[y]-fa[y])$

• 后：$y\in (anc[x]-fa[x])$

• 横：$x\notin anc[y] \ \and \ y\notin anc[x]$ 此时一定满足 $dfn[x]>dfn[y]$

节点上的数字为时间戳：

分析

我们在搜索树上分析，发现“前”边没有什么用处，因为搜索树上本来就存在从 $x$ 到 $y$ 的路径。“后”边非常有用，它可以和搜索树上从 $x$ 到 $y$ 的路径⼀起构成环。“横”边要看情况，如果从 $y$ 出发能找到⼀条路径回到 $x$ 的祖先节点，那么 $x\to y$ 就是有用的。

$low[x]$ 定义为满⾜以下条件的节点的最小时间戳：

• 该点在栈中。

• 存在⼀条从 $sbt[x]$ 出发的有向边，以该点为终点。

$tarjan(x)$ 主体

1. $low[x]=dfn[x]=++dfn\_time$

2. $for(y:e[x])\begin{cases}tarjan(y) \ check\_min(low[x],\color{blue}{low[y]}) & !vis[y] \\ check\_min(low[x],\color{red}{dfn[y]}) & y\in anc[x] \\ do \ nothing & otherwise\end{cases}$

3. $if(low[x]=dfn[x]) \ pop \ stack \ until \ x \ is \ popped \to a \ SCC$

注意标红和标蓝的不能改，不能错！！！

Code

P1407 [国家集训队]稳定婚姻

vector<int> e[N];
int dfn[N];//时间戳
int low[N];//追溯值
int tim=0;//时间戳计数器
int col[N];//所属 SCC （为其中一个点的 id）
int st[N];//stack
int tot=0;//stack_top
bool in[N];//是(1)否(0)在栈中
void tar(int x){
	dfn[x]=low[x]=++tim;//init
	st[++tot]=x;//进栈
	in[x]=1;
	for(int i:e[x]){
		if(!dfn[i]){//萌新
			tar(i);//递归
			ckmn(low[x],low[i]);
		}else if(in[i]){//祖先
			ckmn(low[x],dfn[i]);
		}
	}
	if(low[x]==dfn[x]){//导出 SCC
		do{
			col[st[tot]]=x;
                        //着上 x 的颜色，以后你就是 x 的人了
			in[st[tot]]=0;
		}while(st[tot--]!=x);//pop until x popped
	}
}

Tarjan's BCCs（无向图双连通分量）algorithm

与 SCC 类似，所以符号沿用

注意此时 $low[x]$ 的定义改变，且图 $G$ 中不再存在意义上的“横”边、“前”边。

$low[x]$ 定义为满⾜以下条件之一的节点的最小时间戳：

• 该点在 $sbt[x]$ 中。

• 存在⼀条从该点出发至 $sbt[x]$ 中任一点的非树边。

剩下的分析和算法就一样了~

桥

桥⼀定是搜索树上的边。

$$x\leftrightarrow fa[x] 为桥 \iff dfn[fa[x]]<low[x]$$

Code by FuZhenTao

const int SIZE=100010;
int head[SIZE],ver[SIZE*2],nxt[SIZE*2];
int dfn[SIZE],low[SIZE],n,m,tot,num;
bool bridge[SIZE*2];
void add(int x,int y){
 ver[++tot]=y;
 nxt[tot]=head[x];
 head[x]=tot;
}
void tarjan(int x,int in_edge){
 dfn[x]=low[x]=++num;
 for(int i=head[x];i;i=nxt[i]){
 int y=ver[i];
 if(!dfn[y]){
 tarjan(y,i);
 low[x]=min(low[x],low[y]);
 if(low[y]>dfn[x]) bridge[i]=bridge[i^1]=true;
 }
 else if(i!=(in_edge^1)){
 low[x]=min(low[x],dfn[y]);
 }
 }
}
int main(){
 cin>>n>>m;
 tot=1;
 for(int i=1;i<=m;i++){
 int x,y;
 cin>>x>>y;
 add(x,y);
 add(y,x);
 }
 for(int i=1;i<=n;i++){
 if(!dfn[i]) tarjan(i,0);
 }
 for(int i=2;i<tot;i+=2){
 if(bridge[i]) cout<<ver[i^1]<<" "<<ver[i]<<endl;
 }
}

割点

$$x 为割点 \iff \begin{cases}| \ son[x] \ |>1 & x=rt\\ \exists y\in son[x] \ , \ dfn[x]\leqslant low[y] & x\ne rt\end{cases}$$

Code by FuZhenTao

void tarjan(int x){
 dfn[x]=low[x]=++num;
 int flag=0;
 for(int i=head[x];i;i=nxt[i]){
 int y=ver[i];
 if(!dfn[y]){
 tarjan(y);
 low[x]=min(low[x],low[y]);
 if(low[y]>=dfn[x]){
 flag++;
 if(x!=root||flag>1) cut[x]=true;
 }
 }
 else low[x]=min(low[x],dfn[y]);
 }
}

e-DCC（边双连通分量）

设 $G$ 是无向连通图。

$$G 是 e-DCC \iff \kappa'(G)\geqslant2 \iff 任意⼀条边都包含在至少⼀个简单环中$$

只需要求出无向图中所有的桥，把桥都删除之后，图会分成若干个连通块，每个连通块就是⼀个"边双连通分量"。

Code by FuZhenTao

int c[SIZE],dcc;
void dfs(int x){
 c[x]=dcc;
 for(int i=head[x];i;i=nxt[i]){
 int y=ver[i];
 if(c[y]||bridge[i]) continue;
 dfs(y);
 }
}
for(int i=1;i<=n;i++){
 if(!c[i]){
 ++dcc;
 dfs(i);
 }
}

v-DCC（点双连通分量）

$$G 是 v-DCC \iff \kappa(G)\geqslant2 \iff n(G)\leqslant2 \or 任意两点都包含在至少⼀个简单环中$$

v-DCC 的求法炒鸡麻烦，鸽了。

由于 Tarjan $O(n)$ 求 LCA 好像并不是 Tarjan 的算法，而且倍增 $O(n\log n)$ 好用并好写，所以就不再论述了。