Tarjan三大算法之双连通分量（双连通分量）

https://blog.csdn.net/fuyukai/article/details/51303292

定义： 

对于一个连通图，如果任意两点至少存在两条点不重复路径，则称这个图为 点双连通的（简称双连通）；如果任意两点至少存在两条边不重复路径，则称该图为 边双连通的。点双连通图的定义等价于任意两条边都同在一个简单环中，而边双连通图的定义等价于任意一条边至少在一个简单环中。对一个无向图，点双连通的极大子图称为 点双连通分量（简称双连通分量），边双连通的极大子图称为 边双连通分量。这篇博客就是总结一下求解无向图点双连通分量与边双连通分量的方法。

算法： 
求解点双连通分量与边双连通分量其实和求解割点与桥密切相关。不同双连通分量最多只有一个公共点，即某一个割顶，任意一个割顶都是至少两个点双连通的公共点。不同边双连通分量没有公共点，而桥不在任何一个边双连通分量中，点双连通分量一定是一个边双连通分量。 
下面首先介绍点双连通分量的Tarjan算法： 
在之前的博客中，我们已经知道如何求解割顶了，很容易可以发现，当我们找到割顶的时候，就已经完成了一次对某个极大点双连通子图的访问，那么我们如果在进行DFS的过程中将遍历过的点保存起来，是不是就可以得到点双连通分量了？为了实现算法，我们可以在求解割顶的过程中用一个栈保存遍历过的边（注意不是点！因为不同的双连通分量存在公共点即割顶），之后每当找到一个点双连通分量，即子结点v与父节点u满足关系low[v]>=dfn[u]，我们就将栈里的东西拿出来直到遇到当前边。 
这里注意放入栈中的不是点，而是边，这是因为点双连通分量是存在重复点的，如果我们放入栈中的是点，那么对于某些点双连通分量，就会少掉一些点（这些点都是割顶）。 
代码：

struct Edge{
    int u,v;
    Edge(int u=0,int v=0):u(u),v(v){}
}e[maxm];
int n,m,stamp,dfn[maxn],low[maxn],iscut[maxn],bccno[maxn];
int scnt,stack[maxm],bcc_cnt;
vector<int> vec[maxn],bcc[maxn];

void tarjan(int index,int fa)
{
    int child=0,tmp;
    dfn[index]=low[index]=++stamp;
    for(int i=0;iif(!dfn[tmp])
        {
            stack[++scnt]=vec[index][i],child++;
            tarjan(tmp,index);
            low[index]=min(low[index],low[tmp]);
            if(low[tmp]>=dfn[index])
            {
                iscut[index]=1;
                bcc[++bcc_cnt].clear();
                while(1)
                {
                    int num=stack[scnt--];
                    if(bccno[e[num].u]!=bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(e[num].u);
                        bccno[e[num].u]=bcc_cnt;
                    }
                    if(bccno[e[num].v]!=bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(e[num].v);
                        bccno[e[num].v]=bcc_cnt;
                    }
                    if(e[num].u==index && e[num].v==tmp)
                        break;
                }
            }
        }
        else if(dfn[tmp]stack[++scnt]=vec[index][i];
            low[index]=min(low[index], dfn[tmp]);
        }
    }
    if(fa<0 && child==1)
        iscut[index]=0;
}

void find_bcc()
{
    // 割顶的bccno值无意义 
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(iscut,0,sizeof(iscut));
    memset(bccno,0,sizeof(bccno));
    memset(bcc,0,sizeof(bcc));
    stamp=scnt=bcc_cnt=0;
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            tarjan(i,-1);
}

• 
  

这里需要十分注意的是，算法结束之后，每个结点会有一个编号，代表它属于哪一个点双连通分量，但是，割顶的编号是完全没有意义的！这个算法灵活使用了两个时间戳和栈，完成了点双连通分量的发现。 
例题：UVALIVE 5135

之后介绍边双连通分量的求解算法： 
边双连通分量的求解非常简单，因为边双连通分量之间没有公共边，而且桥不在任意一个边双连通分量中，所以算法十分简单，即先一次DFS找到所有桥，再一次DFS（排除了桥）找到边双连通分量。 
PS：当然可以用一次DFS实现。 
代码：

struct Edge{
    int u,v;
    Edge(int u=0,int v=0):u(u),v(v){}
}e[maxm];
int n,m,stamp,dfn[maxn],low[maxn],bccno[maxn],bcc_cnt;
vector<int> vec[maxn],bcc[maxn];
bool g[maxn][maxn],isbridge[maxm];

void tarjan(int index,int fa)
{
    int tmp;
    dfn[index]=low[index]=++stamp;
    for(int i=0;iif(!dfn[tmp])
        {
            tarjan(tmp,index);
            low[index]=min(low[index],low[tmp]);
            if(low[tmp]>dfn[index])
                isbridge[vec[index][i]]=isbridge[vec[index][i]^1]=1;
        }
        else if(dfn[tmp]void dfs(int index)
{
    dfn[index]=1;
    bccno[index]=bcc_cnt;
    for(int i=0;iint tmp=vec[index][i];
        if(isbridge[tmp])
            continue;
        if(!dfn[e[tmp].v])
        {
            dfs(e[tmp].v);
        }
    }
}

void find_ebcc(){
    bcc_cnt=stamp=0;
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(isbridge,0,sizeof(isbridge));
    memset(bccno,0,sizeof(bccno));
    memset(bcc,0,sizeof(bcc));
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            tarjan(i, -1);
    memset(dfn,0,sizeof(dfn));
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i])
        {
            bcc_cnt++;
            dfs(i);
        }
    }               
}

例题：POJ 3352

Codeforces 962F Simple Cycles Edges [Tarjan+点双连通分量]

题意：给你一张无自环，无重边的无向图，定义简单环是环中的点只出现一次，求所有的只包含在一个简单环中的边。

题解：由于只能包含在一个简单环中，我们可以考虑tarjan缩点，然后我们对于以下这张图。

根据题意我们可以得到答案是6条边，因此我们需要通过点双连通分量缩点，而不是边双连通分量缩点。之后我们只要计算每一个点双连通分量中，点的数量与边的数量是否相同，就可以判断这个分量中的边是否满足条件。

点双连通分量内容，请移至博客：https://blog.csdn.net/acterminate/article/details/52526920

AC代码：

#include
#include
#include
#include
#include
#define N 100005
#define M 200005
using namespace std;
struct edge
{
    int to,next;
    edge(){}
    edge(int to,int next)
    {
        this->to=to;
        this->next=next;
    }
}ed[M];
vector<int>vt[N];
int head[N],lnum,esum,index,top,bccnum;
int dfn[N],low[N],mark[M],bj[N],st[M],belong[M],isCut[N],num[N];
pair<int,int>E[M];
void addline(int from,int to)
{
    ed[lnum]=edge(to,head[from]);
    head[from]=lnum++;
}
void tarjan(int root,int fa){//有自环时不加自环的边
                            //点双连通缩点方法：清空路径，枚举E[]数组中存储的路径，建立双向边。
    dfn[root]=low[root]=++index; //新点初始化
    int child=0;
//初始节点需要两个以上儿子且dfn[root]<=low[v] 才是割点
    for(int i=head[root];~i;i=ed[i].next){ //遍历root指出去的边
        int v=ed[i].to;
        if(mark[i]) continue;
        mark[i]=mark[i^1]=1;
        st[++top]=i;//边入栈，需注意此语句要放在判continue之后
         if(!dfn[v]){ //如果v节点未去过，搜索v节点
            child++;
            tarjan(v,root);
            low[root]=min(low[root],low[v]); //更新low值
            if(dfn[root]<=low[v]){
                isCut[root]=1;          //此点是割点，需注意初始节点要有两个儿子
                bccnum++;//注意这里是N++，建数组时要注意开至少两倍大
                for(;;){
                    int j=st[top--];
            //bj[]数组用来标记节点所属的bcc，割点会改变，无意义
            //E[]存新图的边，esum是其数量，tarjan结束后建双向边
                    if(bj[ed[j].to]!=bccnum){
                        bj[ed[j].to]=bccnum;
                        num[bccnum]++;
                        E[++esum]=make_pair(ed[j].to,bccnum);
                    }
                    if(bj[ed[j^1].to]!=bccnum){
                        bj[ed[j^1].to]=bccnum;
                        num[bccnum]++;
                        E[++esum]=make_pair(ed[j^1].to,bccnum);
                    }
                    belong[(j>>1)+1]=bccnum;//标记边所属的bcc
                    if(i==j)break;
                }
            }
        }
        else low[root]=min(low[root],dfn[v]);
    //与有向图区分，此处else不需要判别v节点是否在栈内
     }
    if(root==fa && child<2)isCut[root]=0;
    //如果初始节点没有2个以上儿子，标记清0
}

void init()
{
    memset(head,-1,sizeof(head));
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(mark,0,sizeof(mark));
    memset(belong,0,sizeof(belong));
    memset(isCut,0,sizeof(isCut));
    top=0;
    lnum=0;
    index=0;
    bccnum=0;
    esum=0;
}
vector<int>ans;
int main()
{
    init();
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        addline(u,v);
        addline(v,u);
    }
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            tarjan(i,i);
    for(int i=1;i<=m;i++)
        vt[belong[i]].push_back(i);
    for(int i=1;i<=bccnum;i++)
        if(vt[i].size()==num[i])
            for(int j=0;j
                ans.push_back(vt[i][j]);
    sort(ans.begin(),ans.end());
    printf("%d\n",ans.size());
    for(int i=0;i
        printf("%d ",ans[i]);
    printf("\n");
}