Tarjan算法求解无向连通图的割点、割边、点双连通分量和边双连通分量的模板

历时好几天，终于完工了！

支持无向图四种功能：
1.割点的求解

2.割边的求解

3.点双连通分量的求解

4.边双连通分量的求解

全部支持重边！！！！全部支持重边！！！！全部支持重边！！！！

测试数据：

10 11
1 5
3 5
4 5
2 4
2 3
4 6
6 8
6 7
7 8
8 10
8 9

/*
By：ZUFE_ZZT
该模板经过多次修改与研究，修正了很多错误，增加了很多功能。
无向图，完全支持重边！！完全支持重边！！
【功能如下】
1.求割点的编号，以及去掉割点有多少连通分量
2.求点双连通分量
3.求割边的编号
4.求边双连通分量
*/

#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
using namespace std;

const int maxn=+; //结点数量
const int Maxn=*+; //边的数量
int low[maxn];
int dfn[maxn];
int U[maxn],V[maxn];//存初始边
int flag[maxn];//判断第i条边是不是割边
int iscut[maxn];//判断i结点是不是割点，去掉之后有几个连通分量
struct Edge
{
    int from,to,id,ans;//ans为1，表示这条边是割边
} edge[Maxn];
vector<int>G[maxn];//邻接表
int N,M;//N个结点，M条边
int tmpdfn;//时间戳
int tot;
int son;
int Start,End;

//以下是输出点双连通分量用的
int top;
struct Printf_Egde
{
    int u,v,id;
    void output()
    {printf("(%d,%d) ",u,v);}
};
Printf_Egde Stack[Maxn];
int Flag[Maxn];

int TxT[maxn];//求边双连通分量用的

void init()
{
    for(int i=; i<maxn; i++) G[i].clear();
    memset(low,,sizeof(low));
    memset(dfn,,sizeof(dfn));
    memset(iscut,,sizeof(iscut));
    memset(Flag,,sizeof(Flag));
    memset(flag,,sizeof(flag));
    memset(TxT,,sizeof(TxT));
    low[]=dfn[]=;
    tmpdfn=;
    tot=;
    son=;
    top=-;
}

void AddEdge(int u,int v)
{
    edge[tot].from=u;
    edge[tot].to=v;
    edge[tot].id=tot;
    edge[tot].ans=;
    G[u].push_back(tot);
    tot++;

    edge[tot].from=v;
    edge[tot].to=u;
    edge[tot].id=tot;
    edge[tot].ans=;
    G[v].push_back(tot);
    tot++;
}

int Tarjan(int u,int id)
{
    tmpdfn++;
    int lowu=dfn[u]=tmpdfn;
    for(int i=; i<G[u].size(); i++)
    {
        int B=G[u][i];

        Printf_Egde t;
        if(!Flag[edge[B].id/])//没有入过栈
        {
            Flag[edge[B].id/]=;
            t.u=u;
            t.v=edge[B].to;
            t.id=edge[B].id/;
            Stack[++top]=t;
        }
        if(!dfn[edge[B].to])
        {
            int lowv=Tarjan(edge[B].to,edge[B].id);
            lowu=min(lowu,lowv);
            if(lowv>=dfn[u])
            {
                if(u!=) iscut[u]++;
                if(u==) son++;

                //输出点双连通分量
                printf("点双连通分量：");
                while()
                {
                    if(top==-) break;
                    Printf_Egde t1;
                    t1=Stack[top];
                    t1.output();
                    top--;
                    if(t1.id==t.id) break;
                }
                printf("\n");

                //判断是不是割边
                if(lowv>dfn[u])
                    edge[B].ans=;
            }
        }
        else if(dfn[edge[B].to])
        {
            if(edge[B].id/==id/) continue;
            lowu=min(lowu,dfn[edge[B].to]);
        }
    }

    low[u]=lowu;
    return lowu;
}

void Display_Cutting_edge()
{
    for(int i=; i<*M; i++)
        if(edge[i].ans)
            printf("第%d条边是割边：(%d，%d)\n",edge[i].id/,edge[i].from,edge[i].to);

}

void Display_Cutting_point()
{
    if(son>) iscut[]=son-;
    for(int i=Start;i<=End;i++)
        if(iscut[i])
            printf("编号为%d的结点是割点，删除后有%d个连通分量\n",i,iscut[i]+);
}

void Dfs(int x,int y)
{
    int XZ=;
    for(int i=;i<G[x].size();i++)
    {
        int B=G[x][i];
        if(!flag[edge[B].id/])
        {
            XZ=;
            flag[edge[B].id/]=;
            TxT[edge[B].to]=;
            printf("(%d,%d) ",edge[B].from,edge[B].to);
            Dfs(edge[B].to,y+);
        }
    }
    if(!XZ&&!y) printf("(%d) ",x);
}

void Slove()
{
    //把桥都标为1
    for(int i=; i<*M; i++)
        if(edge[i].ans)
            flag[edge[i].id/]=;

    for(int i=Start;i<=End;i++)
    {
        if(!TxT[i])
        {
            TxT[i]=;
            printf("边双连通分量：");
            Dfs(i,);
            printf("\n");
        }
    }
}

int main()
{
    scanf("%d%d",&N,&M);
    init();
    for(int i=; i<M; i++)
    {
        scanf("%d%d",&U[i],&V[i]);
        AddEdge(U[i],V[i]);
    }

    //设置结点编号的起点和终点
    Start=;
    End=N;

    Tarjan(,-);

    //割点的输出
    Display_Cutting_point();

    //割边的输出
    Display_Cutting_edge();

    //点双连通分量在Tarjan过程中已经输出了

    //求边双连通分量，并输出
    Slove();

    return ;
}