kosaraju 和 tarjan算法详解(强连通分量）
定 义
在有向图G中，如果任意两个不同的顶点相互可达，则称该有向图是强连通的。
有向图G的极大强连通子图称为G的强连通分支。
转置图的定义：将有向图G中的每一条边反向形成的图称为G的转置GT 。（注意到原图和GT 的强连通分支是一样的）
Korasaju算法
1.深度优先遍历G，算出每个结点u的结束时间f[u],起点如何选择无所谓。
每个结点的结束时间和开始时间是dfs序，开始时间是此点第一次被遍历到时，结束时间为此点已经没法拓展，从栈中弹出，即已经遍历结束，不懂dfs序，可以看这个dfs序
2.深度优先遍历G的转置图GT ，选择遍历的起点时，按照结点的结束时间从大到小进行。遍历的过程中，
一边遍历，一边给结点做分类标记，每找到一个新的起点，分类标记值就加1。
如果此节点已经在反图中遍历过，就不再从它遍历，挑选下一个结束时间晚的
3. 第2步中产生的标记值相同的结点构成深度优先森林中的一棵树，也即一个强连通分量
至于证明。。。emmm，我没看懂，就自己想了一下
如果正图中 b->a,那么反图中为 a->b,而b的结束时间一定比a要晚，所以先遍历b，如果b->a,则说明在原图中a->b
#include
using namespace std;
int f[1000][1000];//存储正图
int rf[1000][1000];//存储反图
int vis[1000];
stack s;//用来存储节点离开时间
stack s1[1000];
int n;
//对原图dfs，找出每个节点的离开时间，用栈存储，直接pop，就不用再逆序
void dfs(int a){
vis[a]=1;
for(int i=1;i<=n;i++){
if(f[a][i]&&!vis[i]){
dfs(i);
}
}
s.push(a);
}
void rdfs(int a,int k){
vis[a]=1;
for(int i=1;i<=n;i++){
if(rf[a][i]&&!vis[i]){
rdfs(i,k);
}
}
s1[k].push(a);//对每个连通分量分支，记录下来
}
int main(){
int m;
cin>>n>>m;
for(int i=1;i<=m;i++){
int x,y;
cin>>x>>y;
f[x][y]=1;
rf[y][x]=1;
}
//对原图dfs
for(int i=1;i<=n;i++){
if(!vis[i])
dfs(1);
}
memset(vis,0,sizeof(vis));
int k=0;
//对反图dfs
while(!s.empty()){
if(!vis[s.top()])//节点按照节点离开时间从大到小遍历
rdfs(s.top(),++k);//计算连通分量个数
s.pop();
}
cout< 用邻接表写的代码（老师写的）
#include
#include
const int V = 1e4 + 7, E = 5e4 + 7;
int hd[V], to[E], fr[E], nt[E], pr[E], tl[E];
int n, m, id[V], vis[V], cnt[V], scc;
bool out[V];
void dfs(int u, int &clk) {//用引用，减少全局变量的使用
id[u] = 1;
for (int i = hd[u]; i; i = nt[i])
if (!id[to[i]]) dfs(to[i], clk);
vis[++clk] = u;//当一个节点是叶子节点时，记录结束时间且只记录结束时间
}
void rdfs(int v, int clk) {
id[v] = clk, ++cnt[clk];
for (int i = tl[v]; i; i = pr[i])
if (!id[fr[i]]) rdfs(fr[i], clk);
}
void Korasaju() {
for (int i = 1, clk = 0; i <= n; ++i) if (!id[i]) dfs(i, clk);//最晚结束时间必然是n
for (int i = 1; i <= n; ++i) id[i] = 0;
for (int i = n; i; --i)
if (!id[vis[i]]) rdfs(vis[i], ++scc);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; ++i) {
scanf("%d%d", &u, &v);
nt[i] = hd[u], pr[i] = tl[v], hd[u] = tl[v] = i;
to[i] = v, fr[i] = u;//同时存储正向与反向图
}
int ans = 0;
Korasaju();
//自此，产生了一个以强连通分量编号作为结点，构成的一个DAG图
for (int i = 1; i <= n; ++i)
for (int j = hd[i]; j; j = nt[j])
if (id[i] != id[to[j]]) out[id[i]] = true;
//如果度用++统计的话，需要考虑两个连通分量之间存在重复边（此题并不需要）
for (int i = 1; i <= scc; ++i)
if (!out[i]) {
if (ans) { puts("0"); return 0; }
ans = cnt[i];
}
printf("%d\n", ans);
return 0;
}
tarjan算法（很重要）
low数组和dfn数组，dfn是第一次搜到此点的时间戳，low值是此点所连接的点中最小dfn
栈用来存储搜索到的点
沿着起点一直搜索，如果搜到返祖边，则将此点的low值更改，low[u]=min(low[u],dfn[v])
至于为什么是dfn[v],不是low[v]？
low[v]并不是最终结果，不该使用，就算low[v]=dfn[v],也不使用他
当此点无法再搜下去，比较dfn与low值，相等则说明栈中从此点一直到栈顶为一个连通分量，将这些从栈中弹出，然后回溯，回溯时比较点的low值，再次更新low值，low[u]=min(low[u],low[v])
至于缩点只要将一个分量的染色就好了
受欢迎的牛
有用的定理
有向无环图中唯一出度为0的点，一定可以由任何点出发均可达(由于无环，所以从任何点出发往前走，必然终止于
一个出度为0的点)
因为强连通所有点都可互相到达，可以把强连通分量缩成一个点，如果有唯一的一个点的出度为0，那么这个分量的个数即为答案
如果不止一个出度为0，则无解。
#include
#include
#include
#include
using namespace std;
int n,m;
const int e=1e4+4;
//标记时间戳
int low[e],dfn[e],index;
//tarjan中的栈，和判断是否在栈中
stack s;
bool ins[e];
//标记所属分量，用于缩点
int col[e];
//计算有几个分量
int cnt;
//每个分量中的成员
vector ve[e];
//邻接表
struct edge{
int to,next;
};
edge f[5*e];
int head[e],id;
void add(int from,int to){
f[++id].next=head[from];
f[id].to=to;
head[from]=id;
}
//Tarjan
void Tarjan(int u){
dfn[u]=low[u]=++index;
s.push(u);
ins[u]=1;
for(int i=head[u];i;i=f[i].next){
int v=f[i].to;
if(!dfn[v])//没有深搜的点
Tarjan(v)，low[u]=min(low[u],low[v]);//回溯阶段，无法继续探索，则从底往上逐级返回//low值
else if(ins[v])
low[u]=min(low[u],dfn[v]);//在栈中的点
}
//当此点全部探索完成，low值依然没有改变，说明为联通分量的根节点 ，可以出栈
if(dfn[u]==low[u]){
++cnt;
int t;
do{
t=s.top();
s.pop();
ins[u]=0;//标记出栈
ve[cnt].push_back(t);
col[t]=cnt;//缩点（染色标记）
}while(t!=u);
}
}
int main(){
cin>>n>>m;
for(int i=1;i<=m;i++){
int a,b;
cin>>a>>b;
add(a,b);
}
for(int i=1;i<=n;i++){
if(!dfn[i])
Tarjan(i);
}
int out[e]={0};//统计每个联通块的出度
for(int i=1;i<=n;i++){
for(int j=head[i];j;j=f[i].next){
int to=f[i].to;
if(col[i]!=col[to])//不是同一个连通块，则出度+1
++out[col[i]];
}
}
int sum=0,ans;
for(int i=1;i<=cnt;i++){
if(!out[i]) sum++,ans=ve[i].size();
}
if(sum==1)
cout< 对于tarjan中的栈的用处，有个博客写的特别详细
https://blog.csdn.net/qq_38234381/article/details/79981531
用数组模拟栈的写法（老师写的）
#include
#include
const int V = 1e4 + 7, E = 5e4 + 7;
//hd-head, fr-from, nt-next, pr-pre, tl-tail
int hd[V], to[E], nt[E], lbl[V], cnt[V], low[V], dfn[V], stk[V], tp, scc;
bool out[V];
void Tarjan(int u, int &clk){
low[u] = dfn[u] = ++clk;
stk[++tp] = u;
for (int i = hd[u]; i; i = nt[i])
if (not dfn[to[i]])
Tarjan(to[i], clk), low[u] = std::min(low[u], low[to[i]]);
else if (not lbl[to[i]])
low[u] = std::min(low[u], dfn[to[i]]);
if (low[u] == dfn[u])
for (++scc; stk[tp+1] != u; --tp)
lbl[stk[tp]] = scc, ++cnt[scc];
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; ++i) {
scanf("%d%d", &u, &v);
nt[i] = hd[u], hd[u] = i, to[i] = v;
}
for (int i = 1, clk = 0; i <= n; ++i)
if (not lbl[i]) Tarjan(i, clk);
for (int i = 1; i <= n; ++i)
for (int j = hd[i]; j; j = nt[j])
if (lbl[i] != lbl[to[j]]) out[lbl[i]] = true;
int ans = 0;
for (int i = 1; i <= scc; ++i)
if (not out[i]) {
if (ans) { puts("0"); return 0; }
ans = cnt[i];
}
printf("%d\n", ans);
return 0;
}
缩点+建图
用pair存储每条边的两个端点，重点在于处理自环边和重复边，用sort处理，重新建图
#include
#include
#include
const int N = 5e5 + 7;
int hd[N], to[N], fr[N], nx[N], stk[N], tp, scc;
int low[N], dfn[N], id[N], sum[N], w[N], ans;
bool bar[N], inq[N], stop[N];
std::pair eg[N];
void Tarjan(int u, int &clk) {
low[u] = dfn[u] = ++clk;
stk[++tp] = u;
for (int i = hd[u], v; i; i = nx[i])
if (!dfn[v=to[i]])
Tarjan(v, clk), low[u] = std::min(low[u], low[v]);
else if (!id[v])
low[u] = std::min(low[u], dfn[v]);
if (low[u] == dfn[u])
for (++scc; stk[tp+1] != u; --tp)
id[stk[tp]] = scc, sum[scc] += w[stk[tp]], stop[scc] |= bar[stk[tp]];
}
int dis[N];
void spfa(int s) {
std::queue que;
que.push(s), ans = dis[s] = sum[s];
while (que.size()) {
int u = que.front(); que.pop();
inq[u] = false;
for (int i = hd[u]; i; i = nx[i]) {
int v = to[i], tot = dis[u] + sum[v];
if (dis[v] < tot) {
dis[v] = tot;
if (stop[v]) ans = std::max(ans, dis[v]);
if (not inq[v]) que.push(v);
}
}
}
}
int main() {
int n, m, s, p;
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; ++i) {
scanf("%d%d", &u, &v);
nx[i] = hd[u], hd[u] = i, to[i] = v, fr[i] = u;
}
for (int i = 1; i <= n; ++i) scanf("%d", w+i);
scanf("%d%d", &s, &p);
for (int i = 1, x; i <= p; ++i)
scanf("%d", &x), bar[x] = true;
for (int i = 1, clk = 0; i <= n; ++i) if (!dfn[i]) Tarjan(i, clk);
//缩点建新图
for (int i = 1; i <= m; ++i)
eg[i].first = id[fr[i]], eg[i].second = id[to[i]];
std::sort(eg+1, eg+m+1);
for (int i = 1; i <= scc; ++i) hd[i] = 0;
for (int i = 1; i <= m; ++i) {
int u = eg[i].first, v = eg[i].second;
int uu = eg[i-1].first, vv = eg[i-1].second;
if (u!=v && (u!=uu || v!=vv))//清除自环边和重复边
nx[i] = hd[u], hd[u] = i, to[i] = v;
}
//在新图上直接跑spfa
spfa(id[s]);
printf("%d\n", ans);
return 0;
}