【W的AC企划 - 第八期】tarjan缩点

往期浏览

讲解

（有向图）强连通分量缩点

概念

强连通分量缩点后的图称为 SCC。

有两种方式会导致形成 SCC，其一是存在一条后向边，直接指向某个祖先节点；其二是存在一条横叉边，横叉边指向某个祖先节点。

求解强连通分量：该算法主要依赖于 dfs，定义两个数组，time 数组代表遍历到该点的时间戳， upper 数组代表从该点开始走能走到的最小时间戳。对于某一点 \(x\) ，如果满足 time[x] == upper[x] ，说明这个点位于一个强连通分量的最上层，这时可以借助栈 S 来获得 \(x\) 所在 SCC 的全部点的编号：一直到 \(x\) 出栈为止，这些点都属于同一个 SCC。

强连通分量缩点操作过程：对于任意的边 \((x_i,y_i)\) ，如果它们不属于同一个强连通分量，那么就建立一条新边。

最终我们以 \(\mathcal O (N + M)\) 的复杂度完成上述全部操作。

个人封装

struct SCC {
    int n;
    vector<vector<int>> ver;
    vector<int> dfn, low, col, S;
    int now, cnt;

    SCC(int n) : n(n) {
        ver.assign(n + 1, {});
        dfn.resize(n + 1, -1);
        low.resize(n + 1);
        col.assign(n + 1, -1);
        S.clear();
        now = cnt = 0;
    }
    void add(int x, int y) {
        ver[x].push_back(y);
    }
    void tarjan(int x) {
        dfn[x] = low[x] = now++;
        S.push_back(x);
        for (auto y : ver[x]) {
            if (dfn[y] == -1) {
                tarjan(y);
                low[x] = min(low[x], low[y]);
            } else if (col[y] == -1) {
                low[x] = min(low[x], dfn[y]);
            }
        }
        if (dfn[x] == low[x]) {
            int pre;
            cnt++;
            do {
                pre = S.back();
                col[pre] = cnt;
                S.pop_back();
            } while (pre != x);
        }
    }
    pair<int, vector<vector<int>>> rebuild() { // [新图的顶点数量, 新图]
        work();
        vector<vector<int>> adj(cnt + 1);
        for (int i = 1; i <= n; i++) {
            for (auto j : ver[i]) {
                int x = col[i], y = col[j];
                if (x != y) {
                    adj[x].push_back(y);
                }
            }
        }
        return {cnt, adj};
    }
    void work() {
        for (int i = 1; i <= n; i++) { // 避免图不连通
            if (dfn[i] == -1) {
                tarjan(i);
            }
        }
    }
};

（无向图）割边缩点

概念

割边缩点后的图称为 E-DCC。

较有向图中 SCC 的形成更简单，只有一种方式会形成 E-DCC，即不存在一条边，直接指向某个祖先节点。

求解割边：我们同样维护 time 和 upper 两个时间戳数组。对于某一条边 \((x-y)\) ，如果满足 time[x] < upper[y] ，说明 \(y\) 不能到达 \(x\) 的任何一个祖先节点，这条边就是割边。然而，在处理重边问题时，借助 \(\tt vector\) 的方法无法对之进行处理（例如同时存在 \((u,v)\) 和 \((v,u)\) 两条边时，链式前向星可以借助 h 数组直接区分这两个 u 的不同，进而判断这条边不是割边，但是在 \(\tt vector\) 数组中这两个 u 是相同的），故求解割边一般都采用链式前向星建图法。

求解边双：如果满足 time[z] == upper[z] ，\(z\) 就位于一个边双的最上层，同样可以借助栈 S 来获得 \(z\) 所在边双的全部点的编号：一直到 \(z\) 出栈为止，这些点都属于同一个 E-DCC 。

边双缩点操作过程：旧图中的每一条割边即为新图中的一条边，获取割边两端点颜色后直接连接即可。下方给出的链式前向星方法是在求解割边的基础上顺便将边双缩点，如果不需要求解割边而只需要将边双缩点，那么直接套用 SCC 缩点的做法即可。

个人封装

struct E_DCC {
    int n;
    vector<int> h, ver, ne;
    vector<int> dfn, low, col, S;
    int now, cnt, tot;
    vector<bool> bridge; // 记录是否是割边

    E_DCC(int n, int m) : n(n) {
        m *= 2; // 注意链式前向星边的数量翻倍
        ver.resize(m + 1);
        ne.resize(m + 1);
        bridge.resize(m + 1);
        
        h.resize(n + 1, -1);
        dfn.resize(n + 1);
        low.resize(n + 1);
        col.resize(n + 1);
        S.clear();
        tot = cnt = now = 0;
    }
    void add(int x, int y) { // 注意，这里的编号从 0 开始
        ver[tot] = y, ne[tot] = h[x], h[x] = tot++;
        ver[tot] = x, ne[tot] = h[y], h[y] = tot++;
    }
    void tarjan(int x, int fa) { // 这里是缩边双，不是缩点，不相同
        dfn[x] = low[x] = ++now;
        S.push_back(x);
        for (int i = h[x]; ~i; i = ne[i]) {
            int y = ver[i];
            if (!dfn[y]) {
                tarjan(y, i); // 这里储存的是父亲边的编号
                low[x] = min(low[x], low[y]);
                // y 不能到达 x 的任何一个祖先节点，(x - y) 即为一条割边
                // 但是在这里，我们不直接储存 (x - y) 这条边，而是储存边的编号
                // 这样做是为了处理重边的情况（点可能相同，但是边的编号绝对不相同）
                if (dfn[x] < low[y]) {
                    bridge[i] = bridge[i ^ 1] = true;
                }
            } else if (i != (fa ^ 1)) { // 这里同样的，使用边的编号来处理重边情况
                low[x] = min(low[x], dfn[y]);
            }
        }
        if (dfn[x] == low[x]) {
            int pre = 0;
            cnt++;
            do {
                pre = S.back();
                S.pop_back();
                col[pre] = cnt;
            } while (pre != x);
        }
    }
    pair<int, vector<vector<int>>> rebuild() { // [新图的顶点数量, 新图]
        work();
        vector<vector<int>> adj(cnt + 1);
        for (int i = 0; i < tot; ++i) {
            if (bridge[i]) { // 如果 (i, i ^ 1) 是割边
                int x = col[ver[i]], y = col[ver[i ^ 1]];
                adj[x].push_back(y); // 割边两端点颜色必定不同，故直接连边
            }
        }
        return {cnt, adj};
    }
    void work() {
        for (int i = 1; i <= n; i++) { // 避免图不连通
            if (dfn[i] == 0) {
                tarjan(i, -1);
            }
        }
    }
};

（无向图）割点缩点

概念

割点缩点后的图称为 V-DCC。

求解割点：我们同样维护 time 和 upper 两个时间戳数组。对于某一条边 \((x-y)\) ，如果满足 time[x] <= upper[y] ，说明 \(y\) 不能到达 \(x\) 的任何一个祖先节点，这时有两种情况，其一是当 \(x\) 不为根节点时，那么显然 \(x\) 是一个割点；其二时当 \(x\) 为根节点时，那么只有当 \(x\) 至少拥有两个子节点时，其才为割点。所以我们还需要维护两个变量，其一是 \(x\) 是否为当前根节点，其二是 \(x\) 的子节点数量。

求解点双：同样借助栈 S 来维护，这里与求解 SCC 和 E-DCC 都不相同——对于某一条边 \((x-y)\) ，只要我们确定了 \(x\) 是割点，就直接开始弹栈操作，一直到 \(y\) 出栈为止，这些点都属于同一个 V-DCC 。而由于下方性质，所以额外的将 \(x\) 也看做属于这个 V-DCC 。除此之外，由于判断条件的变化，我们需要特判：若一个点是孤立点，那么它也是一个 V-DCC 。

点双缩点操作过程：旧图中的每一个割点都是新图中的一个点，旧图中的 V-DCC 都需要向其所包含的每一个割点各连一条边。

struct V_DCC {
    int n;
    vector<vector<int>> ver, col;
    vector<int> dfn, low, S;
    int now, cnt;
    vector<bool> point; // 记录是否为割点

    V_DCC(int n) : n(n) {
        ver.resize(n + 1);
        dfn.resize(n + 1);
        low.resize(n + 1);
        col.resize(2 * n + 1);
        point.resize(n + 1);
        S.clear();
        cnt = now = 0;
    }
    void add(int x, int y) {
        if (x == y) return; // 手动去除重边
        ver[x].push_back(y);
        ver[y].push_back(x);
    }
    void tarjan(int x, int root) {
        low[x] = dfn[x] = now++;
        S.push_back(x);
        if (x == root && !ver[x].size()) { // 特判孤立点
            ++cnt;
            col[cnt].push_back(x);
            return;
        }

        int flag = 0;
        for (auto y : ver[x]) {
            if (!dfn[y]) {
                tarjan(y, root);
                low[x] = min(low[x], low[y]);
                if (dfn[x] <= low[y]) {
                    flag++;
                    if (x != root || flag > 1) {
                        point[x] = true; // 标记为割点
                    }
                    int pre = 0;
                    cnt++;
                    do {
                        pre = S.back();
                        col[cnt].push_back(pre);
                        S.pop_back();
                    } while (pre != y);
                    col[cnt].push_back(x);
                }
            } else {
                low[x] = min(low[x], dfn[y]);
            }
        }
    }
    pair<int, vector<vector<int>>> rebuild() { // [新图的顶点数量, 新图]
        work();
        vector<vector<int>> adj(cnt + 1);
        for (int i = 1; i <= cnt; i++) {
            if (!col[i].size()) { // 注意，孤立点也是 V-DCC
                continue;
            }
            for (auto j : col[i]) {
                if (point[j]) { // 如果 j 是割点
                    adj[i].push_back(point[j]);
                    adj[point[j]].push_back(i);
                }
            }
        }
        return {cnt, adj};
    }
    void work() {
        for (int i = 1; i <= n; ++i) { // 避免图不连通
            if (!dfn[i]) {
                tarjan(i, i);
            }
        }
    }
};