无向图的割点与桥

 给定无向连通图G=(V,E);

割点：

若对于，从图中删去节点x与所有与x关联的边后，G分为两个或以上不相连的子图，则称x为G的割点。

割边：

若对于，从图中删去边e之后，G分为两个不相连的子图，则称e为桥或割边。

割边的判定法则：

无向边（x,y)是桥，当且仅当搜索树上存在x的一个子节点y，满足：dfn[x]<low[y]

hdu4738

#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
int n, m, cnt, h[N], dfn[1010], low[1010], ind, ans, mp[1010][1010];
struct node {
    int v, nt, w;
} no[N];
void add(int u, int v, int w) {
    no[cnt] = node{v, h[u], w};
    h[u] = cnt++;
}
void tarjan(int u, int fa) {
    low[u] = dfn[u] = ++ind;
    for(int i = h[u]; ~i; i = no[i].nt) {
        int v = no[i].v;
        if(!dfn[v]) {
            tarjan(v, u);
            low[u] = min(low[u], low[v]);
            if(dfn[u] < low[v])
                ans = min(ans, mp[u][v]);//最小边
        } else if(v != fa)
            low[u] = min(low[u], dfn[v]);
    }
}
int main() {
    while(~scanf("%d%d", &n, &m) && (n + m)) {
        memset(h, -1, sizeof h), cnt = 0, ind = 0, ans = 10010;
        memset(dfn, 0, sizeof dfn);
        memset(low, 0, sizeof low);
        memset(mp, 0, sizeof mp);
        for(int u, v, w, i = 1; i <= m; i++) {
            scanf("%d%d%d", &u, &v, &w);
            if(mp[u][v] == 0)//处理重边
                add(u, v, w), add(v, u, w);
            else if(mp[u][v])
                mp[u][v] = mp[v][u] = 10010;
            if(mp[v][u] == 0)
                mp[u][v] = mp[v][u] = w;
        }
        int lt = 0;
        for(int i = 1; i <= n; i++)
            if(!dfn[i])
                tarjan(i, 0), lt++;
        if(ans == 10010)
            ans = -1;
        if(ans == 0)
            ans = 1;
        if(lt > 1)
            ans = 0;
        printf("%d\n", ans);
    }
    return 0;
}

割点判定法则：

若x不是搜索树的根节点（深度优先遍历的起点），则x是割点当且仅当搜索树上存在x的一个子节点y，满足：dfn[x]low[y]

求割点模板：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e6 + 10;
int n, m, h[N], cnt, dfn[N], low[N], ans, isc[N], ind;
struct node {
    int v, nt;
} no[N];
void add(int u, int v) {
    no[cnt].v = v;
    no[cnt].nt = h[u];
    h[u] = cnt++;
}
void tarjan(int u, int root) {
    dfn[u] = low[u] = ++ind;
    int sun = 0;
    for(int i = h[u]; ~i; i = no[i].nt) {
        int v = no[i].v;
        if(!dfn[v]) {
            tarjan(v, root);//回溯时求
            low[u] = min(low[u], low[v]);
            if(u == root)
                sun++;
            if(low[v] >= dfn[u] && u != root)//形成环
                isc[u] = 1;
        }
        low[u] = min(low[u], dfn[v]);
    }
    if(sun >= 2 && u == root)//有两颗以上的子树
        isc[root] = 1;
}
int main() {
    memset(h, -1, sizeof h);
    scanf("%d%d", &n, &m);
    for(int u, v, i = 1; i <= m; i++) {
        scanf("%d%d", &u, &v);
        add(u, v), add(v, u);
    }
    for(int i = 1; i <= n; i++)
        if(!dfn[i])
            tarjan(i, i);
    for(int i = 1; i <= n; i++)
        if(isc[i])
            ans++;
    printf("%d\n", ans);
    for(int i = 1; i <= n; i++)
        if(isc[i])
            printf("%d ", i);
    return 0;
}