主要讲证明，流程有但比较简洁

---

tarjan

用来求强连通分量，或是求割点割边

求强连通分量

\(dfn_i\) 为 \(i\) 的 dfs 序，\(low_i\) 为 \(i\) 能到达的 dfs 序最小的点的 dfs 序
tarjan 求强连通分量的关键就是找到一个强连通分量的“根”，也就是最早 dfs 到的那个点

dfs 过程中，碰到哪个节点，就将哪个节点入栈。栈中节点只有在其所属的强连通分量已经全部求出时，才会出栈。
对于 \((u\rightarrow v)\)：

• 如果 \(v\) 没有被 dfs 过，则对它 dfs，并 \(low_u=\min(low_u,low_v)\)。因为 \(u\) 可达 \(v\), 所以 \(v\) 可达的最早的节点，也是 \(u\) 可达的。
• 其它情况，也就是它被访问过了，如果 \(v\) 仍没有所属的强连通分量，那么 \(v\) 一定仍在栈中没弹出（至于为什么看如何通过我们求出的这两个数组确定强连通分量的地方就知道了），则是 \(u\) 的一个祖先，更新 \(low_u=\min(low_u,dfn_v)\)
  那此时为什么不更新 \(low_u=\min(low_u,low_v)\)？因为我们在访问这样的 \(v\) 时，一定会访问到一个 dfn 最小的节点，也就是 \(low_v=dfn_v\)，到时候直接用它更新即可

当处理完 \(u\) 的所有出边时，\(dfn_u=low_u\)，那么就把当前栈中的点弹出，直到弹到 \(u\)，这些点构成一个强连通分量，那么 \(u\) 也就是这个强联通分量的“根”
那么我们证明为什么最后这样是可行的
把此时的点分成几类

1. 还没被访问的节点
2. 栈中进栈比 \(u\) 早的节点
3. 栈中进栈比 \(u\) 晚的节点
4. 进过栈，但已经出栈的节点
5. 节点 \(u\)

对这几类点分别阐述是不是在当前强连通分量中：

1. 不在，显然

2. 不在，\(low_u=dfn_u\)，无论如何 \(u\) 也到不了比它进栈早的点

3. 在。设这样的节点用 \(x\) 表示。显然 \(u\) 可以到达 \(x\)。那么证明为什么 \(x\) 可以到达 \(u\)

   • 若 \(dfn_x=low_x\)，那么在处理到 \(x\) 时，发现 \(x\) 是另一个强连通分量的“根”，此时就把 \(x\) 出栈了，矛盾
   • 若 \(low_x=dfn_y\)，那么有 \(dfn_y>dfn_u\)，因为 \(u\rightarrow x\rightarrow y\)，如果 \(dfn_y<dfn_u\)，那么就是 \(low_u=dfn_y<dfn_u\) 了，不成立
     此时也有 \(dfn_y=low_y\)，否则 \(low_x\) 肯定可以更小，那又因为 \(dfn_y>dfn_u\)，所以这个节点 \(y\) 也被当作强连通分量的“根”处理过，和 \(x\) 一起出栈了，矛盾

4. 不在。

   • 如果比 \(u\) 更早被 dfs 到，并且更早的出了栈，说明 \(u\) 不能达到它
     如果能到达，那么 \(low_u=dfn_x<dfn_u\)，不成立
   • 如果比 \(u\) 晚被 dfs 到，则它不能达到 \(u\)
     设 \(low_x=dfn_y\)，只有满足 \(dfn_y>dfn_u\)，它才能在处理 \(u\) 之前弹出栈
     而如果它能达到 \(u\)，那么又因为 \(dfn_u<dfn_y\)，所以应该是 \(low_x=dfn_u\)，矛盾了

5. 在，显然

愉快的写出代码

void tarjan(int u){
	stack[++top]=u;low[u]=dfn[u]=++dfscnt;
	for(reg int v,i=fir[u];i;i=nex[i]){
		v=to[i];
		if(!dfn[v]){
			tarjan(v);
			low[u]=std::min(low[u],dfn[v]);
		}
		else if(!scc[v]) low[u]=std::min(low[u],dfn[v]);
	}
	if(dfn[u]==low[u]){
		scccnt++;
		do{
			scc[scccnt]=stack[top];
		}while(stack[top--]!=u)
	}
}

原文地址：https://www.cnblogs.com/suxxsfe/p/12720339.html