Tarjan 之 有向图(强连通分量)、无向图(割点/点双、割边/边双) (板子总结)

upd：

2023.7.3更新，加入一个图论小证明

2020.3.3更新，加入边双

2019.12.27更新，加入点双

2019.4.4更新，强连通分量、割点、割边

思路来源

理解：

https://www.cnblogs.com/nullzx/p/7968110.html（比较清晰的tarjan图示）

Tarjan三大算法之双连通分量（双连通分量）_LP_Cong的博客-优快云博客（双连通分量）

https://www.cnblogs.com/szy-wlxy/p/4639316.html（求点双边双连通图）

代码：

无向图的割顶和桥，无向图的双连通分量入门详解及模板_去掉桥后的的连通分图_STILLxjy的博客-优快云博客（比较清晰的C++板子）

https://www.cnblogs.com/letlifestop/p/10262951.html（割点代码参考）

模板，无向图强连通缩点，tarjan_无向图缩点建图_utoppia的博客-优快云博客（无向图双连通分量缩点）

心得

tarjan属于dfs相关，蓝桥杯考的还是很多的

现在补一下板子，争取以后都能手敲出来tarjan

还有边的那个别用初始化head -1和~i了

以后用e[++cnt]和head初始为0的版本，比较好用

也不用把每个的下标可以减1了

开的数组虽多，但命名还算挺清楚的吧

计数器只会命tot num cnt的我枯了 这么多计数器

有向图

强连通分量板子（以poj2186为例）

加入对in[v]的判断，判断v在栈内，

是防止n=2，m=1，1->2，先搜2的情况发生

此时2先退栈，1会搜到已经退栈的2，但dfn[1]仍应等于low[1]

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1e4+5;
const int maxm=5e4+5;
int n,m,u,v;
int res,ans;//最后答案 出度为0点的个数 
int head[maxn],cnt;
int low[maxn],dfn[maxn],num;//最早非负祖先时间戳 时间戳 
int stack[maxn],top,now;//用数组模拟栈 栈顶 当前栈顶值 
int par[maxn],tot;//染色 颜色数 
bool in[maxn];//是否在栈中 
int out[maxn];//如果不在一个连通分量里 统计出度  
int sum[maxn];//每个连通分量里的点的个数 
struct edge
{
	int to,next;
}e[maxm];
void add(int u,int v)
{
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
void dfs(int u)
{
	low[u]=dfn[u]=++num;
	in[u]=1;
	stack[++top]=u;
	for(int i=head[u];i;i=e[i].next)
	{
		int v=e[i].to;
		if(!dfn[v])
		{
			dfs(v);
			low[u]=min(low[u],low[v]);
		}
		else if(in[v])
		{
			low[u]=min(low[u],dfn[v]);
		}
	}
	if(low[u]==dfn[u])//环的第一个点 
	{
		tot++;
		do
		{
			now=stack[top--];
			par[now]=tot;
			sum[tot]++; 
			in[now]=0; 
		}while(now!=u);
	}
}
void init()
{
	memset(head,0,sizeof head);
	memset(sum,0,sizeof sum);
	memset(in,0,sizeof in);
	memset(out,0,sizeof out); 
	res=ans=cnt=num=top=tot=0;
}
void solve()
{
	for(int i=1;i<=n;++i)
	if(!dfn[i])dfs(i);
	for(int u=1;u<=n;++u)
	{
		for(int i=head[u];i;i=e[i].next)
		{
			int v=e[i].to;//u->v的有向边 
			//不在同一个连通分量里
			if(par[u]!=par[v])out[par[u]]++; 
		}
	} 
	for(int i=1;i<=tot;++i)//枚举连通分量 
	{
		if(!out[i])//该连通分量 出度为0
		{
			ans++;
			res=sum[i]; 
		} 
	}
}
int main()
{
	while(~scanf("%d%d",&n,&m))
	{
		init();
		for(int i=1;i<=m;++i)
		{
			scanf("%d%d",&u,&v);
			add(u,v);
		}
		solve();
		printf("%d\n",ans==1?res:0);
	}
	return 0;
}

无向图

割点板子（以poj1144为例）

割点：当删去这个点时，连通块的数量会增加。

从u利用u->v去搜v，如果v不能通过非u的点到达比u的时间戳更早的点(low[v]>=dfn[u])，说明u是割点

注意，特判根节点，根节点连有>=2个块时，根才是割点；=1时，删掉根，连通块数并未增加

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=110;
const int maxm=2e4+10;
int head[maxn],cnt;
int low[maxn],dfn[maxn],num;
int n,ans;
int u,v;
bool cut[maxn];//是否是割点 
struct edge
{
	int to,next;
}e[maxm];
void add(int u,int v)
{
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
void init()
{
	memset(cut,0,sizeof cut);
	memset(head,0,sizeof head);
	memset(low,0,sizeof low);
	memset(dfn,0,sizeof dfn);
	ans=num=cnt=0;
}
void dfs(int u,int fa)
{
	low[u]=dfn[u]=++num;
	int ch=0;
	for(int i=head[u];i;i=e[i].next)
	{
		int v=e[i].to;
		if(!dfn[v])
		{
			dfs(v,u);
			ch++;//从u这里向下dfs的子树的数量 
			low[u]=min(low[u],low[v]);
			if(low[v]>=dfn[u])cut[u]=1;//有一个 u就是割点 
		}
		else if(dfn[v]<dfn[u] && v!=fa)
		low[u]=min(low[u],dfn[v]);
	}
	if(fa==0&&ch==1)cut[u]=0;//特判根节点 有两棵及以上子树才可 
}
int main()
{
	while(~scanf("%d",&n)&&n)
	{
		init();
		while(~scanf("%d",&u)&&u)
		{
			while((getchar())!='\n')
			{
				scanf("%d",&v);
				add(u,v);add(v,u);
			}
		}
		for(int i=1;i<=n;++i)
		if(!dfn[i])dfs(i,0);
		for(int i=1;i<=n;++i)
		if(cut[i])ans++;
		printf("%d\n",ans);
	}
	return 0;
}

割边板子（以牛客小白月赛12 I-华华和月月逛公园 为例）

割边（桥）：当删去这个边时，连通块的数量会增加。

如果u-v，从u去搜v，v如果能通过别的边到达比u更早的点(含u)(low[v]<=dfn[u])，则说明有环，非桥，

否则有low[v]>dfn[u]成立，此时是桥边

i!=(in^1)，加入对反向边的判断，是防止n=2，m=1，1-2一条边的情况，

此时1-2是一条桥边，如省去该判断，则会当做一个n=2的环，从而误判

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1e5+10;
const int maxm=6e5+10;
int n,m,head[maxn];
int cnt=1;//这里是为了初始情况下，2和3的异或对应关系 
int dfn[maxn],low[maxn],num;
bool bridge[maxm];
int ans,u,v;
struct edge
{
    int to,next;
}e[maxm];
void add(int u,int v)
{
    e[++cnt].to=v;
    e[cnt].next=head[u];
    head[u]=cnt;
}
void dfs(int u,int in)
{
    low[u]=dfn[u]=++num;
    for(int i=head[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(!dfn[v])
        {
            dfs(v,i);
            low[u]=min(low[u],low[v]);
            if(low[v]>dfn[u])
            bridge[i]=bridge[i^1]=1;
        }
        else if(i!=(in^1))
        low[u]=min(low[u],dfn[v]);
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;++i)
    {
        scanf("%d%d",&u,&v);
        add(u,v),add(v,u);
    }
    for(int i=1;i<=n;++i)
    if(!dfn[i])dfs(i,0);
    for(int i=2;i<cnt;i+=2)
    if(bridge[i])ans++;//bridge 
    printf("%d\n",m-ans);
    return 0;
}

点双连通分量（以UvaLive3523 为例）

点双连通分量是指在一个无向图中两点间至少有两条路径，且路径中（不算头尾）的点不同。

不同的点双连通分量最多有一个公共点，这个点必定是割点。

割点一定属于至少两个点双，因此割点的数组编号无意义，去每个点双vector里找点即可

此题的解法，先求点双连通分量，然后判断每个点双是否是二分图

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
const int N=1e3+10,M=1e6+10;
using namespace std;
#define pb push_back
#define fi first
#define se second
typedef pair<int,int> P;
int n,m,ans,u,v,col[N],odd[N];
int low[N],dfn[N],cut[N],tot,belong[N],top,cnt;
P stk[M];
bool ban[N][N];
vector<int>bcc[N],e[N];
//点双板子
void dfs(int u,int fa){
	low[u]=dfn[u]=++tot;
	int ch=0;
	for(int i=0;i<e[u].size();++i){
		int v=e[u][i];
		if(!dfn[v]){
            stk[++top]=P(u,v);//记录当前BCC的边
			dfs(v,u);
			ch++;//从u这里向下dfs的子树的数量
			low[u]=min(low[u],low[v]);
			if(low[v]>=dfn[u]){//割点u
                cut[u]=1;//有一个 u就是割点
                ++cnt;bcc[cnt].clear();
                for(;;){
                    P x=stk[top--];
                    int y=x.fi,z=x.se;
                    if(belong[y]!=cnt){
                        bcc[cnt].pb(y);
                        belong[y]=cnt;
                    }
                    if(belong[z]!=cnt){
                        bcc[cnt].pb(z);
                        belong[z]=cnt;
                    }
                    if(y==u && z==v)break;
                }
			}
		}
		else if(v!=fa && dfn[v]<dfn[u]){
            stk[++top]=P(u,v);
            low[u]=min(low[u],dfn[v]);
		}
	}
	if(fa==-1 && ch==1)cut[u]=0;//特判根节点 有两棵及以上子树
}
bool bip(int u,int c,int bc){
    col[u]=c;
    for(int i=0;i<e[u].size();++i){
        int v=e[u][i];
        if(belong[v]!=bc)continue;//不在同一点双里
        if(col[v]==c)return 0;
        if(col[v]==-1 && !bip(v,!c,bc))return 0;
    }
    return 1;
}
void findbcc(int n){
    memset(dfn,0,sizeof dfn);
    memset(cut,0,sizeof cut);
    memset(belong,0,sizeof belong);
    tot=top=cnt=0;
    for(int i=1;i<=n;++i){
        if(!dfn[i]){
            dfs(i,-1);
        }
    }
}
int main(){
    //freopen("my.out","w",stdout);
    while(~scanf("%d%d",&n,&m)){
        if(!n && !m)break;
        for(int i=1;i<=n;++i){
            e[i].clear();
        }
        memset(ban,0,sizeof ban);
        for(int i=1;i<=m;++i){
            scanf("%d%d",&u,&v);
            ban[u][v]=ban[v][u]=1;
        }
        for(int i=1;i<=n;++i){
            for(int j=i+1;j<=n;++j){
                if(!ban[i][j]){
                    //printf("(%d,%d)\n",i,j);
                    e[i].pb(j);
                    e[j].pb(i);
                }
            }
        }
        findbcc(n);
        memset(odd,0,sizeof odd);
        for(int i=1;i<=cnt;i++){
            memset(col,-1,sizeof col);
            for(int j=0;j<bcc[i].size();++j){
                int u=bcc[i][j];
                belong[u]=i;//割点出现在多个点双里
            }
            if(!bip(bcc[i][0],1,i)){
                for(int j=0;j<bcc[i].size();++j){
                    int u=bcc[i][j];
                    //printf("%d ",u);
                    odd[u]=1;
                }
            }
            bcc[i].clear();
        }
        ans=n;
        for(int i=1;i<=n;++i){//i位于奇圈内 顺便初始化
            if(odd[i])ans--;
        }
        printf("%d\n",ans);
    }
	return 0;
}

边双连通分量（以牛客练习赛56 E-小雀和他的王国为例）

边双连通分量是指在一个无向图中两点间至少有两条路径，且路径中的边不同。

边双连通分量中一定没有割边（桥）。

法一：

求出割边之后，刻意避开割边dfs一次原图，即可得到哪些点是同一个双连通分量的

也可以，维护一个并查集，在判断u-v不是割边时，将u-v合并

如果将同一双连通分量里的点缩点，重新建图，则新图里的边只有割边

法二：

忽略反向边时，强连通分量的求法，

考虑忽略反向边之后，只有桥边回不来，同一边双内的点有两条路径，故仍可达

以牛客练习赛56 E-小雀和他的王国为例，先对边双缩点建新图，这里采用法二

新图是一棵树，边都是原图中的桥，求树的直径即可，Gym100712H原题

#include<iostream>
#include<cstdio>
#include<vector>
const int N=2e5+10,mod=1e9+7;
using namespace std;
typedef pair<int,int> P;
#define pb push_back
#define fi first
#define se second
struct edge{
    int u,v;
}f[N];
int n,m,mx,ps,ps2,u,v;
int low[N],dfn[N],tot,belong[N],stk[N],top,cnt;
bool vis[N];
vector<P>e[N];
//边双板子
void tarjan(int u,int E){
    low[u]=dfn[u]=tot++;
    vis[u]=1;
    stk[++top]=u;
    for(int i=0;i<e[u].size();++i){
        int v=e[u][i].fi,id=e[u][i].se;
        if(E==id)continue;//同一条边的反向边
        if(!vis[v]){
            tarjan(v,id);
            low[u]=min(low[u],low[v]);
        }
        else{
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u]){
        ++cnt;
        do{
            belong[stk[top]]=cnt;
        }while(top&&stk[top--]!=u);
    }
}
void dfs(int u,int fa,int dep){
    if(dep>mx)mx=dep,ps=u;
    for(int i=0;i<e[u].size();++i){
        int v=e[u][i].fi;
        if(v==fa)continue;
        dfs(v,u,dep+1);
    }
}
int modpow(int x,int n,int mod){
    int res=1;
    for(;n;n>>=1,x=1ll*x*x%mod){
        if(n&1)res=1ll*res*x%mod;
    }
    return res;
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;++i){
        scanf("%d%d",&u,&v);
        f[i]=edge{u,v};
        e[u].pb(P(v,i));
        e[v].pb(P(u,i));
    }
    for(int i=1;i<=n;++i){
        if(!dfn[i]){
            tarjan(i,-1);
        }
    }
    for(int i=1;i<=n;++i){
        e[i].clear();
    }
    for(int i=0;i<m;i++){
        u=f[i].u,v=f[i].v;
        if(belong[u]!=belong[v]){
            e[belong[u]].pb(P(belong[v],i));
            e[belong[v]].pb(P(belong[u],i));
        }
    }
    mx=ps=-1;
    dfs(1,-1,0);
    ps2=ps;
    mx=ps=-1;
    dfs(ps2,-1,0);
    //for(int i=1;i<=n;++i)
    //printf("I:%d be:%d\n",i,belong[i]);
    printf("%d\n",1ll*(cnt-1-mx)*modpow(m+1,mod-2,mod)%mod);
    return 0;
}

图论小证明

问题来自于gzchenben的ppt

证明：

任何一个非平凡（点数不为1）无向连通图上，至少有两个非割点。

证明：

考虑无向连通图的dfs树，

1. 要么为一条只有一个叶子的链（且叶子不等于根)

此时，把根这个度为1的点也看做是叶子

2. 要么有大于等于2个叶子

那么，只要割掉这两个叶子即可

可以发现，不管叶子有没有返祖边，都不影响原图的连通性