求割点 割边 Tarjan

附上一般讲得不错的博客 https://blog.csdn.net/lw277232240/article/details/73251092

https://www.cnblogs.com/collectionne/p/6847240.html

https://blog.csdn.net/zhn_666/article/details/77971619

然后附上模板题:              https://vjudge.net/problem/HihoCoder-1183

裸题,直接要你输出割点 和 割边.. 唯一坑点就是割边的输出..自己看题.

#include <set>
#include <cstdio>
#include <algorithm>

using namespace std;

struct Point {
    int u;
    int v;
    Point () { }
    Point (int uu, int vv) : u(uu), v(vv) { }
    bool operator < (const Point &a) const {
        if (u != a.u) return u < a.u;
        return v < a.v;
    }
};

struct Edge {
    int lst;
    int to;
}edge[200500];
int head[20500];
int qsz = 1;

inline void add(int u, int v) {
    edge[qsz].lst = head[u];
    edge[qsz].to  = v;
    head[u] = qsz++;
}

int  dfn[20500];
int  low[20500];
//int   pa[20500];
int  dfn_num;
set<int> ans;
set<Point> ans_pt;
/*
void Tarjan(int u) {
    int i, v, child = 0;
    dfn[u] = low[u] = ++dfn_num;
    for (i=head[u]; i; i=edge[i].lst) {
        v = edge[i].to;
        if (v == pa[u]) continue;
        if (!dfn[v]) { // 树边, 父子边
            pa[v] = u;
            Tarjan(v);
            child++;
            low[u] = min(low[u], low[v]);
            //  case 1 u是根节点,同时只是有2颗子树---> 无向图 所以可能有多个根节点.
            if (!pa[u] && child>=2) ans.insert(u) ;  // 根节点是否有多颗子树.. 注意 这个是写在if (!vis[u])里面的.
            //  case 2 u是叶子节点, 割点条件是low[v]>=dfn[u]
            if ( pa[u] && low[v] >= dfn[u]) ans.insert(u); // 说明v无法连接到u的祖先.
            //  桥 的条件是: low[v] > dfn[u]
            if (low[v] > dfn[u]) ans_pt.insert(Point(min(u, v), max(v, u))); // 说明v无法连接到u或者u的祖先.
        } else {
            low[u] = min(low[u], dfn[v]);  // u v 为回边
        }
    }
}
*/
void Tarjan(int u, int fa) {
    int i, v, child = 0;
    dfn[u] = low[u] = ++dfn_num;
    for (i=head[u]; i; i=edge[i].lst) {
        v = edge[i].to;
        if (v == fa) continue;
        if (!dfn[v]) { // 树边, 父子边
            Tarjan(v, u);
            child++;
            low[u] = min(low[u], low[v]);
            //  case 1 u是根节点,同时只是有2颗子树---> 无向图 所以可能有多个根节点.
            if (fa==u && child>=2) ans.insert(u) ;  // 根节点是否有多颗子树.. 注意 这个是写在if (!vis[u])里面的.
            //  case 2 u是叶子节点, 割点条件是low[v]>=dfn[u]
            if (fa!=u && low[v] >= dfn[u]) ans.insert(u); // 说明v无法连接到u的祖先.
            //  桥 的条件是: low[v] > dfn[u]
            if (low[v] > dfn[u]) ans_pt.insert(Point(min(u, v), max(v, u))); // 说明v无法连接到u或者u的祖先.
        } else {
            low[u] = min(low[u], dfn[v]);  // u v 为回边
        }
    }
}

int main()
{
//    freopen("E:\\input.txt", "r", stdin);
    int n, m;
    int u, v, i, j;
    scanf("%d%d", &n, &m);
    for (i=1; i<=m; ++i) {
        scanf("%d%d", &u, &v);
        add(u, v);
        add(v, u);
    }
    Tarjan(1, 1);

    if (ans.size()) {
        bool flag = true;

        for (auto iter : ans) {
            if (flag) {
                printf("%d", iter);
                flag = false;
            } else printf(" %d", iter);
        }
    } else {
        printf("Null");
    }
    printf("\n");
    for (auto iter : ans_pt)
        printf("%d %d\n", iter.u, iter.v);    

    return 0;
}

连通度 : 连通图的连通程度. 分为点连通 和 边连通.

割点：在连通图中，删除了连通图的某个点以及与这个点相连的边后，图不再连通。这样的点就是割点。
割边：在连通图中，删除了连通图的某条边后，图不再连通。这样的边被称为割边，也叫做桥。

DFS搜索树：用DFS对图进行遍历时，按照遍历次序的不同，我们可以得到一棵DFS搜索树。

树边：在搜索树中的蓝色线所示，可理解为在DFS过程中访问未访问节点时所经过的边，也称为父子边
回边：在搜索树中的橙色线所示，可理解为在DFS过程中遇到已访问节点时所经过的边，也称为返祖边、后向边

求割点 割边(桥)

注意 low[]和求连通分量的意义不同

求连通分量的low[]的意思是,节点u能访问的最小时间戳

求割点 桥 的low[]的意思是  节点u或u的子树通过回边追溯到最早的祖先节点

void Tarjan(int u, int fa) {
    int i, v, child = 0;
    dfn[u] = low[u] = ++dfn_num;
    for (i=head[u]; i; i=edge[i].lst) {
        v = edge[i].to;
        if (v == fa) continue;
        if (!dfn[v]) { // 树边, 父子边
            Tarjan(v, u);
            child++;
            low[u] = min(low[u], low[v]);
            //  case 1 u是根节点,同时只是有2颗子树---> 无向图 所以可能有多个根节点.
            if (fa==u && child>=2) ans.insert(u) ;  // 根节点是否有多颗子树.. 注意 这个是写在if (!vis[u])里面的.
            //  case 2 u是叶子节点, 割点条件是low[v]>=dfn[u]
            if (fa!=u && low[v] >= dfn[u]) ans.insert(u); // 说明v无法连接到u的祖先.
            //  桥 的条件是: low[v] > dfn[u]
            if (low[v] > dfn[u]) ans_pt.insert(Point(u, v)); // 说明v无法连接到u或者u的祖先.
        } else {
            low[u] = min(low[u], dfn[v]);  // u v 为回边
        }
    }
}

原文地址：https://www.cnblogs.com/cgjh/p/9557760.html