HDU-4081 (次小生成树 + kruskal)

题目大意：有n个城市，每个城市有人口数。给出城市的坐标和人口数。要建最小生成树，但可以选择一条魔法路径，不用花费成本。

魔法路径能够对A人口有利，A是这条魔法路径两端城市的人口总和，生成树的花费是B，求出最大的 A / B。

思路：本题没有直接要求求次小生成树，但需要用到次小生成树中的max数组。先求得最下生成树，再依次遍历每条边，

减去当前路径中的最大边，计算A / B，记录最大值。可以先把每个端点的人口数保存在边上。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<vector>

using namespace std;
typedef long long ll;
const int maxn = 2e3 + 5;
const int maxm = 2e6 + 5;

int n, tot;

struct Node{
    double x, y, p;
}node[maxm];

struct Edge
{
    int x, y;
    double p, len;
}edge[maxm];

int f[maxn];
int vis[maxm];
double maxd[maxn][maxn];

int head[maxm], End[maxm];
struct data
{
    int u, next;
}G[maxn];

double getlen(double x1, double y1, double x2, double y2){
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

bool cmp(Edge a, Edge b){
    return a.len < b.len;
}

int get(int x){
    if(x == f[x]) return f[x];
    return f[x] = get(f[x]);
}

double kru(){
    for(int i = 0; i < n; i++) {
        G[i].u = i;
        G[i].next = -1;
        head[i] = End[i] = i;
        f[i] = i;
        vis[i] = 0;
    }
    int cnt = 0;
    double ans = 0;
    for(int i = 0; i < tot; i++){
        int x = get(edge[i].x);
        int y = get(edge[i].y);
        if(x == y) continue;
        //---------------------次小生成树部分
        for(int j = head[x]; j != -1; j = G[j].next)
            for(int k = head[y]; k != -1; k = G[k].next)
                maxd[G[j].u][G[k].u] = maxd[G[k].u][G[j].u] = edge[i].len;
        G[End[y]].next = head[x];
        head[x] = head[y];
        //---------------------
        f[y] = x;
        ans += edge[i].len;
        cnt++;
        vis[i] = 1;
        if(cnt == n - 1) break;
    }
    return ans;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--){
        scanf("%d", &n);
        for(int i = 0; i < n; i++){
            scanf("%lf %lf %lf", &node[i].x, &node[i].y, &node[i].p);
        }
        tot = 0;
        for(int i = 0; i < n; i++){
            for(int j = i + 1; j < n; j++){
                double len = getlen(node[i].x, node[i].y, node[j].x, node[j].y);
                edge[tot].x = i;
                edge[tot].y = j;
                edge[tot].len = len;
                edge[tot++].p = node[i].p + node[j].p;
            }
        }
        sort(edge, edge + tot, cmp);
        double minlen = kru();
        double ans = 0;
        for(int i = 0; i < tot; i++){
            ans = max(edge[i].p / (minlen - maxd[edge[i].x][edge[i].y]), ans);
        }
        printf("%.2f
", ans);
    }
    return 0;
}