Codeforces - 962F - Simple Cycles Edges（Tarjan 求点双）

题目链接：https://codeforces.com/contest/962/problem/F

6.1 题意

给定一个 $n(1\le n\le 10^5)$ 个节点和 $m(0\le m\le \min (\frac{n(n-1)}{2},10^5))$ 条边的无向图，不含自环和重边，但可能不连通。

现在需要输出图中恰好属于一个简单环上的边。

6.2 解题过程

一个简单环一定存在于连通分量中，而满足题意的边所在的连通分量应该恰好构成一个简单环。

而我们回忆 Tarjan 算法，会发现求连通分量的过程就是在求简单环的过程。

那我们应该求点双呢还是边双呢？

回忆简单环的定义，会发现每个结点只能经过一次，而点双恰好可以保证这一点。

因此我们通过 Tarjan 算法求出每个点双连通分量中的边集，在维护点栈的同时维护一个边栈，当遍历到一个新的边时就将当前边压栈，当点栈弹出时，边栈也跟着弹出。用 vector 存储每个连通分量中边的编号。

如何判定一个连通分量中的点恰好构成一个简单环呢？

如果一个点双中边数等于点数，那么它就是一个简单环。

那么这道题也就做完了。

时间复杂度：$O(n\log n)$。

6.3 错误点

1. 按照自己的写法，存边是按照 $(0,1)$、$(2,3)$ 这样的点对存储的。因此处理点双时，如果当前边的编号为 $id$，则强制按照 $id|1$ 来将边存入到连通分量中，这样可以防止同一条无向边重复计算。
2. 之前采用过比较麻烦的方法来判断一个点双是否为简单环，例如通过每个点的度。这样很容易出错。最便捷的方法就是判断点数是否等于边数。

6.4 代码

int n, m;
int head[maxn], cnt, num, top, tot, top2;
int dfn[maxn], low[maxn], st[maxn], st2[maxn];
bool cut[maxn], vis[maxn];
int mark[maxn], deg[maxn];
vector<int> dcc[maxn], dcc2[maxn];
struct edge
{
    int id, v, nxt;
} Edge[2 * maxn];
void init()
{
    memset(head, -1, sizeof(head));
    cnt = 0;
    num = 0;
    top = 0;
    tot = 0;
}
void addedge(int u, int v, int id)
{
    Edge[cnt].id = id;
    Edge[cnt].v = v;
    Edge[cnt].nxt = head[u];
    head[u] = cnt++;
}
void tarjan(int id, int rt) {
    dfn[id] = low[id] = ++num;
    st[++top] = id;
    if (id == rt && head[id] == -1) {
        dcc[++tot].pb(id);
        return;
    }
    int flag = 0;
    for (int i = head[id]; i != -1; i = Edge[i].nxt) {
        int v = Edge[i].v;
        if (vis[i] || vis[i ^ 1]) continue;
        vis[i] = true;
        st2[++top2] = i;
        if (!dfn[v]) {
            tarjan(v, rt);
            low[id] = min(low[id], low[v]);
            if (low[v] >= dfn[id]) {
                flag++;
                if (id != rt || flag > 1) cut[id] = true;
                tot++;
                int z;
                do {
                    z = st[top--];
                    dcc[tot].pb(z);
                } while (z != v);
                do {
                    z = st2[top2--];
                    dcc2[tot].pb(z | 1);
                } while (z != i);
                dcc[tot].pb(id);
            }
        } else {
            low[id] = min(low[id], dfn[v]);
        }
    }
}
set<int> ans;
int main()
{
    int u, v;
    scanf("%d%d", &n, &m);
    init();
    for (int i = 1; i <= m; i++) {
        scanf("%d%d", &u, &v);
        addedge(u, v, i);
        addedge(v, u, i);
    }
    for (int i = 1; i <= n; i++) {
        if (!dfn[i]) {
            tarjan(i, i);
        }
    }
    int col = 0;
    for (int i = 1; i <= tot; i++) {
        ++col;
        for (auto id: dcc[i]) {
            deg[id] = 0;
        }
        sort(dcc2[i].begin(), dcc2[i].end());
        dcc2[i].erase(unique(dcc2[i].begin(), dcc2[i].end()), dcc2[i].end());
        bool isok = (dcc[i].size() == dcc2[i].size());
        if (!isok) {
            continue;
        }
        for (auto id: dcc2[i]) {
            ans.insert(Edge[id].id);
        }
    }
    printf("%d\n", (int)ans.size());
    for (auto x: ans) {
        printf("%d ", x);
    }
    return 0;
}