tarjan双联通求割点和桥模板

求割点
int n,m,stamp,low[1005],dfn[1005],iscut[1005];//iscut记录的为割点
vector<int> vec[1005];
void tarjan(int index,int fa){
    int child=0;
    low[index]=dfn[index]=++stamp;
    for(int i=0;i<vec[index].size();i++)
    {
        int tmp=vec[index][i];
        if(!dfn[tmp])
        {
            child++;
            tarjan(tmp,index);
            low[index]=min(low[index],low[tmp]);
            if(low[tmp]>=dfn[index])
                iscut[index]=1;
        }
        else if(dfn[tmp]<dfn[index] && tmp!=fa)
        {
            low[index]=min(low[index],dfn[tmp]);
        }
    }
    if(fa<0 && child==1)
        iscut[index]=0;
}

求桥

int head[N],dfn[N],low[N],belong[N],de[N],stack[N],bridge[M][2],ins[N],dcnt,bcnt,top,bnum;
struct edge
{
    int u,v,next;
}e[2*M];

void add(int u ,int v ,int k)
{
    e[k].u = u; e[k].v = v; e[k].next = head[u]; head[u] = k++;

    e[k].u = v; e[k].v = u; e[k].next = head[v]; head[v] = k++;
}

void dfs(int u ,int fa)
{
    dfn[u] = low[u] = ++dcnt;
    stack[++top] = u; ins[u] = 1;//ins数组用于记录在此连通块中是否走过
    for(int k=head[u]; k!=-1; k=e[k].next)
    {
        int v = e[k].v;
        if(v == fa) continue;
        if(!dfn[v]) //树边
        {
            dfs(v,u);
            low[u] = min(low[u] , low[v]);
            if(low[v] > dfn[u]) //边(u,v)为桥，可以统计一个边连通分支
            {
                //保存桥
                bridge[bnum][0] = u;//bridge用于记录桥的两边元素，u为父结点
                bridge[bnum++][1] = v;

                ++bcnt;//bcnt用于记录双联通块的数量
                while(true)
                {
                    int x = stack[top--];
                    ins[x] = 0;
                    belong[x] = bcnt;//belong记录结点x属于哪一个连通块
                    if(x == v) break;
                }//注意点u并没有出栈，因为点u属于另一个边连通分量
            }
        }
        else if(ins[v]) //后向边
            low[u] = min(low[u] , dfn[v]);
        //横叉边为（dfn[v] && !ins[v]），跳过
    }
}