社交网络图中结点的“重要性”计算

很有意思。
先看了一眼题目时限：20000 ms，这特么？？什么题啊？？
读完题后，哦，乱搞题。
不禁想起了那句台词：
“你就叫我太子好了，我承受的起”。
“原来是小bei三啊”。

下面说正事：
floyd, 时间复杂度O(n ^ 3)

// floyd
#include <bits/stdc++.h>

constexpr int inf = std::numeric_limits<int>::max() >> 1;

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    // std::cout << std::right << std::setw(5) << std::setfill('0');
    // std::cout << std::fixed << std::setprecision(6);
    
    int n, m;
    std::cin >> n >> m;

    std::vector<std::vector<int>> dist(n + 1, std::vector<int>(n + 1, inf));
    for (int i = 1; i <= n; ++i) {
        dist[i][i] = 0;
    }

    std::vector<std::vector<int>> G(n + 1);
    for (int i = 0; i < m; ++i) {
        int u, v;
        std::cin >> u >> v;

        G[u].push_back(v);
        G[v].push_back(u);
        dist[u][v] = dist[v][u]= 1;
    }

    int cnt = 0;
    std::vector<bool> vis(n + 1, false);
    auto dfs = [&](auto&& dfs, int u) -> void {
        if (vis[u]) return;
        vis[u] = true;
        ++cnt;
        for (int v : G[u]) {
            dfs(dfs, v);
        }
    };
    dfs(dfs, 1);
    bool is_connected = cnt == n;

    if (is_connected) {
        for (int k = 1; k <= n; ++k) {
            for (int i = 1; i <= n; ++i) {
                for (int j = 1; j <= n; ++j) {
                    if (dist[i][k] < inf && dist[k][j] < inf) {
                        dist[i][j] = std::min(dist[i][k] + dist[k][j], dist[i][j]);
                    }
                }
            }
        }
    }

    int k;
    std::cin >> k;

    while (k--) {
        int x;
        std::cin >> x;

        if (!is_connected) {
            printf("Cc(%d)=0.00\n", x);
            continue;
        }

        double ans = 0.0;
        for (int i = 1; i <= n; ++i) {
            ans += dist[x][i];
        }
        ans /= n - 1;
        ans = 1.0 / ans;

        printf("Cc(%d)=%.2lf\n", x, ans);
    }
    
    return 0;
}

dijkstra, 时间复杂度O(k * nlogn)

// dijkstra
#include <bits/stdc++.h>

constexpr int inf = std::numeric_limits<int>::max() >> 1;

struct Edge {
    int v, d;
    bool operator<(const Edge& rhs) const {
        return d > rhs.d;
    }
};

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    
    int n, m;
    std::cin >> n >> m;

    std::vector<std::vector<int>> G(n + 1);
    for (int i = 0; i < m; ++i) {
        int u, v;
        std::cin >> u >> v;

        G[u].push_back(v);
        G[v].push_back(u);
    }

    std::vector<int> dist(n + 1);
    std::vector<bool> done(n + 1);
    auto dijkstra = [&](int s) -> void {
        std::fill(dist.begin(), dist.end(), inf);
        std::fill(done.begin(), done.end(), false);
        std::priority_queue<Edge> PQ;

        PQ.push(Edge{s, 0});
        dist[s] = 0;

        while (!PQ.empty()) {
            int u = PQ.top().v; PQ.pop();
            if (done[u]) continue;
            done[u] = true;
            for (int v : G[u]) {
                if (dist[u] + 1 < dist[v]) {
                    dist[v] = dist[u] + 1;
                    PQ.push(Edge{v, dist[v]});
                }
            }
        }
    };

    int cnt = 0;
    std::vector<bool> vis(n + 1, false);
    auto dfs = [&](auto&& dfs, int u, int fa) -> void {
        if (vis[u]) return;
        vis[u] = true;
        ++cnt;
        for (int v : G[u]) {
            dfs(dfs, v, u);
        }
    };
    dfs(dfs, 1, 0);
    bool is_connected = cnt == n;

    int k;
    std::cin >> k;

    while (k--) {
        int x;
        std::cin >> x;

        if (!is_connected) {
            printf("Cc(%d)=0.00\n", x);
            continue;
        }

        dijkstra(x);

        double ans = 0.0;
        for (int i = 1; i <= n; ++i) {
            ans += dist[i];
        }
        ans /= n - 1;
        ans = 1.0 / ans;

        printf("Cc(%d)=%.2lf\n", x, ans);
    }
    
    return 0;
}

spfa, 时间复杂度O(km)

// spfa
#include <bits/stdc++.h>

constexpr int inf = std::numeric_limits<int>::max() >> 1;

struct Edge {
    int v, d;
};

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    
    int n, m;
    std::cin >> n >> m;

    std::vector<std::vector<int>> G(n + 1);
    for (int i = 0; i < m; ++i) {
        int u, v;
        std::cin >> u >> v;

        G[u].push_back(v);
        G[v].push_back(u);
    }

    std::vector<int> dist(n + 1);
    std::vector<bool> inq(n + 1);
    auto spfa = [&](int s) -> void {
        std::fill(dist.begin(), dist.end(), inf);
        std::fill(inq.begin(), inq.end(), false);
        std::queue<Edge> Q;

        Q.push(Edge{s, 0});
        inq[s] = true;
        dist[s] = 0;

        while (!Q.empty()) {
            int u = Q.front().v; Q.pop();
            for (int v : G[u]) {
                if (dist[u] + 1 < dist[v]) {
                    dist[v] = dist[u] + 1;
                    if (!inq[v]) {
                        Q.push(Edge{v, dist[v]});
                        inq[v] = true;
                    }
                }
            }
        }
    };

    int cnt = 0;
    std::vector<bool> vis(n + 1, false);
    auto dfs = [&](auto&& dfs, int u, int fa) -> void {
        if (vis[u]) return;
        vis[u] = true;
        ++cnt;
        for (int v : G[u]) {
            dfs(dfs, v, u);
        }
    };
    dfs(dfs, 1, 0);
    bool is_connected = cnt == n;

    int k;
    std::cin >> k;

    while (k--) {
        int x;
        std::cin >> x;

        if (!is_connected) {
            printf("Cc(%d)=0.00\n", x);
            continue;
        }

        spfa(x);

        double ans = 0.0;
        for (int i = 1; i <= n; ++i) {
            ans += dist[i];
        }
        ans /= n - 1;
        ans = 1.0 / ans;

        printf("Cc(%d)=%.2lf\n", x, ans);
    }
    
    return 0;
}