模板总结——割点、桥与双连通分支

基本概念

割点：如果将连通图G中的某个点及与其相关的边删除后，使得连通分量数量增加，那么这个点就称为图G的割点或是接合点。

桥：如果在图G中删去一条边后，图G的连通分支数增加，则称边为图G的桥或割边或关节边。

双连通图：如果一个无向图没有割点，则是双连通图。

tarjan算法原理

对图进行一次dfs遍历，即建一颗dfs树，得到每个点的dfn（被访问时的深度）和low（可以到达的被访问时间最早的祖先的深度）。
对所有点u和它在dfs树种的子结点vi：
如果存在low[v]>=dfn[u],则u是一个割点；
如果存在low[v]>dfn[u],则边（u，v）是桥。
特别地，如果根结点有两个及以上的子结点，那么根结点是割点。
时间复杂度：O(n+m).

注意割点和桥不要再tarjan中输出和计数，因为可能重复。

割点和桥tarjan模板

const int maxn=1600;
int vis[maxn],low[maxn],dfn[maxn];
bool cut[maxn],bridge[maxn][maxn];
vector<int> g[maxn];
void tarjan(int u,int fa,int dep)
{
    vis[u]=1;low[u]=dfn[u]=dep;
    int childsum=0;
    for(int i=0;i<g[u].size();i++)
    {
        int v=g[u][i];
        if(v!=fa && vis[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
        if(!vis[v])
        {
            tarjan(v,u,dep+1);
            childsum++;
            low[u]=min(low[u],low[v]);
        }
        if(fa==-1 && childsum>1)
            cut[u]=true;
        if(fa!=-1 && low[v]>=dfn[u])
            cut[u]=true;
        if(low[v]>dfn[u])
            bridge[u][v]=bridge[v][u]=true;
    }
}

边双连通分支

边双连通分支：不存在桥的连通分支。
另一种描述是连通图中任意两点都存在两条不相交的路径（组成路径的边集没有交集）。

算法原理：一种直观的方法就是先通过tarjan算法求出桥，然后dfs一遍图，根据桥来分割连通分量。
另一种优化后的方法是维护一个栈，在tarjan算法中每次访问一个点时将点入栈。当u和u的子树的low和dfn都求出后，判断dfn[u]是否等于low[u]。如果相等，说明（fa[u]，u）是一个桥。因为dfn[fa[u]]小于dfn[u],所以low[u]大于dfn[fa[u]]。那么fa[u]和u就属于两个不同的边双连通分支，根据dfs的特性，不断将栈内的元素弹出直到遇到u，这弹出的元素（包括u）组成一个边双连通分支。

边双连通模板

//hihocoder#1184 : 连通性二·边的双连通分量
//http://hihocoder.com/problemset/problem/1184
#include <bits/stdc++.h>
using namespace std;

const int maxn=2e4+100;
const int maxm=1e5+100;
typedef pair<int,int> pa;
vector<pa> g[maxn];
bool bridge[maxm];
int belong[maxn],dfn[maxn],low[maxn],n,m,sum,cnt;
vector<int> a[maxn];
stack<int> sta;

void tarjan(int u,int fa,int dep)
{
    dfn[u]=low[u]=dep;
    sta.push(u);
    for(int i=0;i<g[u].size();i++)
    {
        int v=g[u][i].first;
        int e=g[u][i].second;

        if(v==fa) continue;
        if(dfn[v])
            low[u]=min(low[u],dfn[v]);
        else
        {
            tarjan(v,u,dep+1);
            low[u]=min(low[u],low[v]);
        }
    }
    if(dfn[u]==low[u])
    {
        ++sum;
        while(!sta.empty())
        {
            int y=sta.top();sta.pop();
            belong[y]=sum;
            if(y==u) break;
        }
    }
}

void solve()
{
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    sum=0;
    memset(belong,0,sizeof(belong));
    tarjan(1,-1,1);
    printf("%d\n",sum);
    for(int i=1;i<=n;i++)
        a[belong[i]].push_back(i);
    for(int i=1;i<=sum;i++)
    {
        int num=1e9;
        for(int j=0;j<a[i].size();j++)
        {
            int tmp=a[i][j];
            num=min(num,tmp);
        }
        for(int j=0;j<a[i].size();j++)
            belong[a[i][j]]=num;
    }
    for(int i=1;i<=n;i++)
    {
        if(i==n) printf("%d\n",belong[i]);
        else printf("%d ",belong[i]);
    }
    for(int i=0;i<=n;i++) g[i].clear(),a[i].clear();
}
int main()
{
    scanf("%d%d",&n,&m);
    {
        cnt=0;
        for(int i=0;i<m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            g[u].push_back(pa(v,++cnt));
            g[v].push_back(pa(u,cnt));
        }
        solve();
    }
    return 0;
}

点双连通分支

点双连通分支：不存在割点的连通分支