缩点前排不全缩点后排全

👁️ 1 人浏览 💬 0 人评论 ❤️ 添加收藏

把上一节那张有环的图缩点：每个强连通分量捏成一个点，分量之间的边保留（去掉重边和自环）。

拿同一个 kahn，在原图和缩点后的图上各排一次，输出各自排出来的个数。

（本题用 g++ -std=c++17 -O0 编译。）

提交你的答案

请登录后提交答案。

去登录

← 从哪几个点出发走遍全图最大流卡在哪儿 →

更多题目

代码编辑器

语言： Ctrl + Enter 运行

#include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;

using Edges = vector<pair<int, int>>;
const int N = 7;
// 七个构建任务，(a, b) 表示 a 做完才能做 b
const Edges DEP = {{0, 1}, {0, 2}, {1, 3}, {2, 3}, {3, 4}, {4, 5}, {4, 6}};
// 同一张图再加一条 5 → 3，于是有了环
const Edges G = {{0, 1}, {0, 2}, {1, 3}, {2, 3}, {3, 4}, {4, 5}, {5, 3}, {4, 6}};

vector<vector<int>> build(const Edges& edges, int n = N) {
    vector<vector<int>> g(n);
    for (auto [a, b] : edges) g[a].push_back(b);
    for (auto& adj : g) sort(adj.begin(), adj.end());
    return g;
}

// Kahn：每次取入度为 0 里编号最小的那个，返回排出来的顺序
vector<int> kahn(const Edges& edges, int n = N) {
    vector<vector<int>> g = build(edges, n);
    vector<int> d(n, 0);
    for (auto [a, b] : edges) d[b]++;
    priority_queue<int, vector<int>, greater<int>> ready;
    for (int u = 0; u < n; u++) {
        if (d[u] == 0) ready.push(u);
    }
    vector<int> out;
    while (!ready.empty()) {
        int u = ready.top();
        ready.pop();
        out.push_back(u);
        for (int v : g[u]) {
            d[v]--;
            if (d[v] == 0) ready.push(v);
        }
    }
    return out;
}

// 第一遍：用手写栈做 DFS，记下每个点「完成」的先后
vector<int> order_by_finish(const vector<vector<int>>& g) {
    vector<bool> seen(N, false);
    vector<int> order;
    for (int s = 0; s < N; s++) {
        if (seen[s]) continue;
        vector<pair<int, int>> st = {{s, 0}};     // (点, 下一条要看的边)
        seen[s] = true;
        while (!st.empty()) {
            int u = st.back().first;
            int i = st.back().second;
            if (i < (int)g[u].size()) {
                st.back().second++;
                int v = g[u][i];
                if (!seen[v]) {
                    seen[v] = true;
                    st.push_back({v, 0});
                }
            } else {
                order.push_back(u);
                st.pop_back();
            }
        }
    }
    return order;
}

// Kosaraju：第二遍在反图上、按完成顺序的逆序收点；返回排好序的分量列表
vector<vector<int>> kosaraju(const Edges& edges, bool second_reversed = true) {
    vector<vector<int>> g = build(edges);
    Edges rev;
    for (auto [a, b] : edges) rev.push_back({b, a});
    vector<vector<int>> rg = build(rev);
    vector<int> order = order_by_finish(g);
    const vector<vector<int>>& second = second_reversed ? rg : g;
    vector<bool> seen(N, false);
    vector<vector<int>> groups;
    for (int k = N - 1; k >= 0; k--) {
        int s = order[k];
        if (seen[s]) continue;
        vector<int> st = {s}, grp;
        seen[s] = true;
        while (!st.empty()) {
            int u = st.back();
            st.pop_back();
            grp.push_back(u);
            for (int v : second[u]) {
                if (!seen[v]) {
                    seen[v] = true;
                    st.push_back(v);
                }
            }
        }
        sort(grp.begin(), grp.end());
        groups.push_back(grp);
    }
    sort(groups.begin(), groups.end());
    return groups;
}

vector<int> comp_of(const vector<vector<int>>& gs) {
    vector<int> comp(N);
    for (int i = 0; i < (int)gs.size(); i++) {
        for (int u : gs[i]) comp[u] = i;
    }
    return comp;
}

// 缩点后的边：两头分量不同才保留，去掉重边，排好序
Edges condense(const Edges& edges, const vector<int>& comp) {
    set<pair<int, int>> s;
    for (auto [a, b] : edges) {
        if (comp[a] != comp[b]) s.insert({comp[a], comp[b]});
    }
    return Edges(s.begin(), s.end());
}

int main() {
    vector<vector<int>> gs = kosaraju(G);
    Edges ce = condense(G, comp_of(gs));
    // TODO: 左边在原图上排一次（N 个点），右边在缩点后的图上排一次（gs.size() 个点）
    size_t before = 0, after = 0;
    cout << before << "/" << after << endl;
}

本次输入：

输出：

👩‍🏫

💬 题目评论

缩点前排不全缩点后排全

更多题目

全部评论