tarjan缩点建图以及双联通求割点，桥模版

tarjan缩点以及重新构图：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#define M 1007
using namespace std;
int dfn[M],low[M],head[M],vis[M],stack[M],belong[M];
int n,m,cnt,scnt,begin,num;
int g[M][M],in[M];
struct E
{
    int v,to;
}edg[M*M];
void init()
{
    memset(head,-1,sizeof(head));
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(belong ,0,sizeof(belong));
    memset(stack,0,sizeof(stack));
    memset(vis,0,sizeof(vis));
    memset(g,0,sizeof(g));
    memset(in,0,sizeof(in));
    cnt=scnt=num=begin=0;
}
void addedge(int u,int v)
{
    edg[num].v=v;edg[num].to=head[u];
    head[u]=num++;
}
void tarjan(int x)
{
    int v;
    dfn[x]=low[x]=++cnt;
    stack[++begin]=x;
    for(int i=head[x];i!=-1;i=edg[i].to)
    {
        v=edg[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[x]=min(low[x],low[v]);
        }
        else if(!vis[v])
            low[x]=min(low[x],dfn[v]);
    }
    if(low[x]==dfn[x])
    {
        scnt++;
        do
        {
            v=stack[begin--];
            belong[v]=scnt;
            vis[v]=1;
        }while(v!=x);
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        init();
        scanf("%d%d",&n,&m);
        int a,b;
        建图
        for(int i=1;i<=n;i++)
            if(!dfn[i])tarjan(i);
        for(int u=1;u<=n;u++)//缩点之后，重新建图
            for(int j=head[u];j!=-1;j=edg[j].to)
            {
                int v=edg[j].v;
                if(u!=v&&belong[u]!=belong[v])
                {
                    g[belong[u]][belong[v]]=1;
                    in[belong[v]]++;
                }
            }
    }
    return 0;
}

求割点：

（1） 若k为深搜树的根Root，当且仅当k的儿子数（分支数）>=2时k为割点；

（2） 若k为搜索树的中间结点（即k既不为根也不为叶），那么k必然有father和son，若AnceDeep[son]>= deep[k]，则k必然为割点。

#include<stdio.h>  
#include<string.h>  
#include<algorithm>  
#define M 1007  
using namespace std;  
int low[M],dfn[M],head[M],vis[M],cut[M];//cut记录割点  
int n,cnt,num,t,root,root_son;  
struct E  
{  
    int to,next;  
}edg[M*20];  
void init()  
{  
    memset(dfn,0,sizeof(dfn));  
    memset(low,0,sizeof(low));  
    memset(head,-1,sizeof(head));  
    memset(vis,0,sizeof(vis));  
    memset(cut,0,sizeof(cut));  
    cnt=0;  
    num=1;  
    n=-1;  
}  
void addedge(int u,int v)  
{  
    edg[cnt].to=v;  
    edg[cnt].next=head[u];  
    head[u]=cnt++;  
}  
void Tarjan(int u)  
{  
    low[u]=dfn[u]=num++;  
    for(int i=head[u];i!=-1;i=edg[i].next)  
    {  
        int v=edg[i].to;  
        if(!dfn[v])  
        {  
            Tarjan(v);  
            if(u==root)//若k为深搜树的根Root，当且仅当k的儿子数（分支数）>=2时k为割点；  
                root_son++;  
            else//若k为搜索树的中间结点（即k既不为根也不为叶），那么k必然有father和son，若low[son]>= dfn[k]，则k必然为割点。  
            {  
                if(low[u]>low[v])  
                    low[u]=low[v];  
                if(low[v]>=dfn[u])  
                    cut[u]=1;  
            }  
        }  
        else if(low[u]>dfn[v])  
            low[u]=dfn[v];  
    }  
}  
int main()  
{  
    int u,v;  
    textcase=0;  
    while(scanf("%d",&n),n)  
    {  
        init();  
        建图 
        root=1;  
        root_son=0;  
        Tarjan(root);  
        if(root_son>1)  
            cut[root]=1;  
    }  
    return 0;  
}  

求桥

void tarjan(int u,int fa)  
{  
    dfn[u]=low[u]=++num;  
    for(int i=head[u]; i!=-1; i=edg[i].next)  
    {  
        int v=edg[i].v;  
        if(v==fa)continue;  
        if(!dfn[v])  
        {  
            tarjan(v,u);  
            low[u]=min(low[u],low[v]);  
            if(low[v]>dfn[u])//桥  
            {  
                bridge[countt++]=i;  
            }  
        }  
        else  
            low[u]=min(low[u],dfn[v]);  
    }  
}