UVA ~ 796 ~ Critical Links （桥）

题意

给定无向图，求割边，按照字典序输出桥。注意输入的时候如果u-v右边，在输入和u有关系的点时会有v，输入和v有关系的点的时候会有u，别存边存多了。

思路

模板。注意存桥的时候，4-3的桥存成3-4。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int MAXM = 1e5 + 5;
struct Edge
{
    int from, to;
    Edge (int from, int to): from(from), to(to) {}
};
struct EdgeBCC//边双联通分量
{
    //有重边也算桥的时候，记得先去重再加边！！！
    int n, m;
    int LOW[MAXN], DFN[MAXN], bccno[MAXN], dfs_clock, bcc_cnt;
    bool isbridge[MAXM];
    vector<Edge> edges, bridge;
    vector<int> G[MAXN];
    void init(int n)
    {
        this->n = n, m = 0;
        edges.clear();
        for (int i = 0; i <= n; i++) G[i].clear();
    }
    void AddEdge (int from, int to)
    { 
        edges.push_back(Edge(from, to));
        edges.push_back(Edge(to, from));
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    int dfs(int u, int fa)
    {
        int lowu = DFN[u] = ++dfs_clock;
        int child = 0;
        bool flag = false;
        for (int i = 0; i < G[u].size(); i++)
        {
            Edge& e = edges[G[u][i]];
            int v = e.to;
            if (v == fa && !flag) { flag = true; continue; }
            if (!DFN[v]) //没有访问过v
            {
                child++;
                int lowv = dfs(v, u);
                lowu = min(lowu, lowv); //用后代的low函数更新自己
                if (lowv > DFN[u])//桥
                {
                    bridge.push_back(Edge(min(u, v), max(u, v)));
                    isbridge[G[u][i]] = isbridge[G[u][i]^1] = true;
                }
            }
            else if (DFN[v] < DFN[u])
                lowu = min(lowu, DFN[v]); //用反向边更新自己        
        }
        LOW[u] = lowu;
        return lowu;
    }
    void dfs2(int u)
    {
        bccno[u] = bcc_cnt;
        for(int i = 0; i < G[u].size(); i++)
        {
            Edge e = edges[G[u][i]];
            if(!isbridge[G[u][i]] && !bccno[e.to])
                dfs2(e.to);
        }
    }
    void find_bcc()
    {
        memset(DFN, 0, sizeof(DFN)), memset(LOW, 0, sizeof(LOW));
        bridge.clear(), memset(bccno, 0, sizeof(bccno));
        dfs_clock = bcc_cnt = 0;
        for (int i = 0; i < n; i++)
            if (!DFN[i]) dfs(i, -1);
        for(int i = 0; i < n; i++)
            if(!bccno[i]) bcc_cnt++, dfs2(i);
    }

}gao;

int n;
int main()
{
    while (~scanf("%d", &n))
    {
        gao.init(n);
        for (int i = 0; i < n; i++)
        {
            int u, v, k;
            scanf("%d (%d)", &u, &k);
            while (k--) 
            {
                scanf("%d", &v);
                if (u < v) gao.AddEdge(u, v);
            }
        }
        gao.find_bcc();
        sort(gao.bridge.begin(), gao.bridge.end(), [](const Edge a, const Edge b)
        { 
            if (a.from != b.from) return a.from < b.from;
            return a.to < b.to;
        });
        printf("%d critical links\n", gao.bridge.size());
        for (auto& i : gao.bridge) printf("%d - %d\n", i.from, i.to);
        printf("\n");
    }   
    return 0;
}
/*
8
0 (1) 1
1 (3) 2 0 3
2 (2) 1 3
3 (3) 1 2 4
4 (1) 3
7 (1) 6
6 (1) 7
5 (0)
0
*/