再入无向图的双连通分量（tarjan神犇%%%%%%%%）

再入有向图的强连通分量

tarjan

连通分量

对于分量中任意两点 $u, v$ ，必然可以从 $u 走到 v$ ，且从 $v 走到 u$

强连通分量 $S C C$

极大连通分量（加上其它任意一个点，都不是连通分量）

应用

将任意一个有向图 $\Rightarrow^{缩点}$ 有向无环图(DAG)拓扑图

求最短路/长路，递推

定义：

树枝边（dfs时的树边）

前向边

后向边

横叉边（只会往左边横叉，往右边其实是树枝边了）

时间戳：对每个点定义两个时间戳

dfn：遍历到u的时间戳

low:从u开始走，所能遍历到的最小时间戳

重要性质：无向图 $D F S$ 后的 $d f s 树$ ，所有的非树边都是从下往上的。

算法(判断 $x$ 是否是在一个强连通分量里)

它可以回到当前搜索树边的祖先节点。（后向边）

走横叉边，横插边可以走到祖先节点。

时间复杂度 $O （ n + m ）$

后续

缩点

for(int i = 1; i <= n; i ++ )
    for(int i = h[x]; ~i; i = ne[i]){
        int j = e[i]
        if(id[i] != id[j]){
			add(id[i], id[j]);
        }
    }

缩点后的DAG图，加最少的边使得图变为强连通分量。

${p\in 起点， Q\in 终点}$

（题目不保证图连通的话，入度和出度要分开算）

证明，不相交起点和终点路径之间连边

拓扑序

连通分量编号 递减的顺序就是拓扑序了。

证明：算导论的dfs拓扑排序做法。

板子

void tarjan(int x){
    dfn[x] = low[x] = ++dfs_clock;
    in_stk[x] = true; stk[++top] = x;
    for(int i = h[x]; ~i; i = ne[i]){
        int j = e[i];
        if(!dfn[j]){
            tarjan(j);
            low[x] = min(low[x], low[j]);
        }else if(in_stk[j]) low[x] = min(low[x], dfn[j]);
    }
    if(low[x] == dfn[x]){
        int y;
        scc_cnt++;
        do{
            y = stk[top--];
            in_stk[y] = false;
            id[y] = scc_cnt;
            siz[scc_cnt]++;
        }while(y != x);
    }
}

作者：HenriHGS
链接：https://www.acwing.com/activity/content/code/content/1737726/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Kosaraju算法

学习地址

逆图学习!!!

一、算法简介

在计算科学中， $K o s a r a j u$ 的算法（又称为– $S h a r i r K o s a r a j u$ 算法）是一个线性时间( $l i n e a r t i m e$ )算法找到的有向图的强连通分量。它利用了一个事实，逆图（与各边方向相同的图形反转, $t r a n s p o s e g r a p h$ ）有相同的强连通分量的原始图。

有关强连通分量的介绍在之前Tarjan 算法中：Tarjan Algorithm

逆图( $T r a n p o s e G r a p h$ )

我们对逆图定义如下：
$G^T=(V,E^T),E^T=\{(u,v):(v,u)\in E\}$
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gLY4tvxp-1633622499654)(D:\aaaa文件夹\工作\文档\模板\图论，似神仙\图床\QQ截图20210906192232.png)]

上图是有向图 $G$ ，和图 $G$ 的逆图 $G^T$

$K o s a r a j u$ 算法就是分别对原图 $G$ 和它的逆图 $G^T$ 进行两遍 $D F S$ ，即：

1).对原图 $G$ 进行深度优先搜索，找出每个节点的完成时间(时间戳)

2).选择完成时间较大的节点开始，对逆图 $G^T$ 搜索，能够到达的点构成一个强连通分量

3).如果所有节点未被遍历，重复2). ，否则算法结束；

#include 
#include 
#include 
#include 
#define x first
#define y second
#define For(i,x,y) for(int i = (x); i <= (y); i ++ )
#define fori(i,x,y) for(int i = (x); i < (y); i ++ )
using namespace std;
const int N =  1e4+10, M = 1e5+10;
int e1[M], e2[M], ne1[M], ne2[M], h1[N], h2[N], idx1, idx2; 
void add1(int a, int b){
    e1[idx1] = b, ne1[idx1] = h1[a], h1[a] = idx1++; 
}
void add2(int a, int b){
    e2[idx2] = b, ne2[idx2] = h2[a], h2[a] = idx2++;
}
int dfn[N], finish[N], dfs_clock;
//typedef pairPII;
//PII p[N];
int ord[N<<1];
void dfs1(int x){
    if(dfn[x]) return;
    dfn[x] = ++dfs_clock;
    for(int i = h1[x]; ~i; i = ne1[i]){
        int j = e1[i];
        dfs1(j);
    }
    finish[x] = ++dfs_clock;//点的完成时间要不同
    ord[finish[x]] = x;
}
int scc_cnt = 0;
bool st[N];
int id[N], tot;
void dfs2(int x){
    if(st[x]) return ;
    tot++;
    st[x] = true;
    id[x] = scc_cnt;
    for(int i = h2[x]; ~i; i = ne2[i]){
        int j = e2[i];
        dfs2(j);
    }
}
int dout[N], siz[N];
int main(){
    memset(h1,-1,sizeof h2);
    memset(h2,-1,sizeof h2);
    idx1 = idx2 = 0;
    int n, m;
    scanf("%d %d", &n, &m);
    For(i,1,m){
        int a,b;
        scanf("%d %d", &a, &b);
        add1(a,b); add2(b,a);
    }
    For(i,1,n)dfs1(i);
  //  For(i,1,n)p[i] = {finish[i],i};
    //sort(p+1,p+1+n);
    memset(st,0,sizeof st);
    for(int i = n*2; i ; i -- ){
        if(ord[i] && !st[ord[i]]) tot = 0,scc_cnt++,dfs2(ord[i]), siz[id[ord[i]]] = tot;
    }
    //题目部分
    For(x,1,n){
        for(int i = h1[x]; ~i; i = ne1[i]){
            int j = e1[i];
            if(id[x] == id[j]) continue;
            dout[id[x]]++;
        }
    }
   // printf("id:");
  //  For(i,1,n) printf("%d ", id[i]);
  //  puts("");
    int sum = 0, zero = 0;
    For(i,1,scc_cnt) {
        if(dout[i]) continue;
        zero++;
        sum += siz[i];
        if(zero > 1) sum = 0;
    }
    printf("%d\n", sum);
    return 0;
}