无向图的割顶、桥和边双连通分量

割顶：割顶是去掉后让无向图不再连通的点,求割顶的算法在DFS遍历的算法上形成。
在一棵DFS树中，
1.根root是割顶------它至少有两个儿子
2.其他点v是割顶------它有一个儿子u, 从u或者u的后代出发没有指向v祖先(不含v)的B边, 则删除v以后u和v的父亲不连通, 故为割顶。

vector<int> g[maxn];
int n,clock, pre[maxn], low[maxn];//pre[]记录每个点的dfs进入计数;low[u]记录u和u的后代能回到的最早的祖先的pre值
bool iscut[maxn];

void dfs(int u, int fa)
{
	low[u] = pre[u] = ++clock;
	int sz = g[u].size(), child = 0;
	for(int i = 0; i < sz; i++)
	{
		int v = g[u][i];
		if(v == fa) continue;
		if(!pre[v])
		{
			child++;
			dfs(v,u);
			low[u] = min(low[u],low[v]);
			if(low[v] >= pre[u]) iscut[u] = true;
		}
		else if(pre[v] < pre[u]) low[u] = min(low[u],pre[v]);
	}
	if(fa < 0 && child == 1) 
        iscut[u] = 0;//根节点是否只有一个儿子,写在外面要判断重边
}

int sloved(int s)
{
	mnemset(pre,0,sizeof(pre));
	memset(iscut,0,sizeof(iscut));
	clock = 0;
	dfs(s,-1);
	if(clock != n) return -1;//原图不连通
	int ans = 0;
	for(int i = 1; i <= n; i++) 
        if(iscut[i]) 
            ans++;
	return ans;
}

边连通度：使一个子图不连通所需要删除的最小的边数就是该图的边连通度。
桥（割边）：当删除一条边就使得图不连通的那条边称为桥或者是割边。
边双连通分量：边连通度大于等于二的子图称为边双连通分量。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <queue>
#include <string>

using namespace std;

/*
 *无向图的桥及边的双连通分量，Tarjan算法O(E)
 */
const int maxn 10000
const int maxm 1000000

struct node
{
    int v, w, pre;  //id：边的编号（处理重边情况）
} edge[maxm];
int pos[maxn], nEdge; //图的存储：链式前向星（池子法）

struct Bridge
{
    int u, v;
} bridge[maxm];  //用来记录桥
int tot; //桥的个数

int fa[maxn], cc; //fa：各个点所属的缩点（连通块），cc连通块的个数
int dfn[maxn], low[maxn], time; //时间戳
int stack[maxn], top;   //用于维护连通块的
int n, m;   //点的个数和边的条数

void connect(int u, int v, int w)
{
    nEdge++;
    edge[nEdge].pre = pos[u];
    edge[nEdge].v = v;
    edge[nEdge].w = w;  //edge[nEdge].id = id;
    pos[u] = nEdge;
}

void tarjan(int cur, int from)
{
    low[cur] = dfn[cur] = time++;
    stack[++top] = cur;
    for (int p=pos[cur]; p; p=edge[p].pre)
    {
        int v = edge[p].v;
        if (v == from) continue;  //注意一下这里.   如果是重边的话，改成：if (edge[p].id == from) continue; 给tarjan传参数from的时候，传递的是当前边的id。
        if (!dfn[v])
        {
            tarjan(v, cur);       //多重边：tarjan(v, edge[p].id);
            if (low[v] < low[cur]) low[cur] = low[v];
            if (low[v] > dfn[cur])
            {
                bridge[tot].u = cur;
                bridge[tot++].v = v;
                cc++;
                do
                {
                    fa[stack[top]] = cc;
                } while (stack[top--] != v);
            }
        } else if (low[cur] > dfn[v]) low[cur] = dfn[v];
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(pos, 0, sizeof(pos));
    nEdge = 0;
    int u, v, w;
    for (int i=0; i<m; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        connect(u, v, w);
        connect(v, u, w);
    }

    memset(dfn, 0, sizeof(dfn));
    memset(fa, -1, sizeof(fa));

    cc = tot = 0;
    for (int i=1; i<=n; i++)   //可以处理不连通的无向图，如果连通只需要一次即可
        if (!dfn[i])
        {
            top = time = 1;
            tarjan(i, -1);
            ++cc;
            for (int j=1; j<=n; j++)   //特殊处理顶点的连通块
                if (dfn[j] && fa[j]==-1) fa[j] = cc;
        }

    for (int i=1; i<=n; i++)
        printf("%d ", fa[i]);  //输出每个节点所属于的连通块（缩点标号）
    printf("\n");

    for (int i=0; i<tot; i++)
        printf("%d %d\n", bridge[i].u, bridge[i].v); //输出所有的桥

    return 0;
}