HDU 4081 次小生成树模板题

先求最小生成树，然后对于最小生成树这个图中的所有点对，求出任意两点之间的所有路径上的最大边，注意是对于构造出来的最小生成树这个图来说。

然后枚举删每一条边，求最优解。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <cmath>
using namespace std;
const int maxn = 1000 + 7;
struct node {
    int u, v;
    double dist;
    int peo;
    bool ok;
    bool operator<(const node &rhs) const {
        return dist < rhs.dist;
    }
}s[maxn*maxn];
struct point {
    int x, y;
    int peo;
}P[maxn];
struct hehe{
    int to;
    double dist;
};
int T, n, m, k;
vector<hehe> G[maxn];
int p[maxn];
double dp[maxn][maxn];

inline int Find(int x) { // 用的克鲁斯卡尔算法求最小生成树
    return p[x] == x ? x : p[x] = Find(p[x]);
}

inline double Distance(int x, int y) {
    return sqrt(1.0 * x * x + 1.0 * y * y);
}

void addEdge(int u, int v, double dist) {
    G[u].push_back((hehe){v, dist});
}

int vis[maxn];

void dfs(int root, int u, double res) {  /// 求最小生成树中任意两点之间的最大边
    for(int i = 0; i < G[u].size(); ++i) {
        hehe &e = G[u][i];
        if(!vis[e.to]) {
            vis[e.to] = 1;
            double MAX = max(e.dist, res);
            dp[root][e.to] = MAX;
            dfs(root, e.to, MAX);
        }
    }
}

double getit() {
    for(int i = 0; i <= n; ++i) p[i] = i;
    double sum = 0.0;
    sort(s, s + k);
    for(int i = 0; i < k; ++i) {
        int x = Find(s[i].u), y = Find(s[i].v);
        if(x != y) {
            p[x] = y;
            addEdge(s[i].u, s[i].v, s[i].dist); /// 将最小生成树建立出来
            addEdge(s[i].v, s[i].u, s[i].dist);
            s[i].ok = true;
            sum += s[i].dist;
        }
    }
    for(int i = 0; i < n; ++i) {
        memset(vis, 0, sizeof(vis));
        dfs(i, i, 0);
    }
    return sum;
}

int main() {
    scanf("%d", &T);
    while(T--) {
        int u, v, peo;
        for(int i = 0; i <= n; ++i) G[i].clear();
        memset(dp, -1, sizeof(dp));
        scanf("%d", &n);
        for(int i = 0; i < n; ++i) {
            scanf("%d%d%d", &u, &v, &peo);
            P[i] = (point){u, v, peo};
        }
        k = 0;
        for(int i = 0; i < n; ++i)
            for(int j = i + 1; j < n; ++j) {
                double d = Distance(P[i].x - P[j].x, P[i].y - P[j].y);
                s[k++] = (node){i, j, d, P[i].peo + P[j].peo, false};
            }
        double sum = getit();
        double ans = -1;
        for(int i = 0; i < k; ++i) {
            if(s[i].ok) { /// 如果是最小生成树中的边
                double q = s[i].peo / (sum - s[i].dist);
                ans = max(ans, q);
            } else {   /// 否则
                int u = s[i].u, v = s[i].v;
                double q = s[i].peo / (sum - dp[u][v]);
                ans = max(ans, q);
            }
        }
        printf("%.2f\n", ans);
    }
    return 0;
}