uvalive 5731 Qin Shi Huang’s National Road System

题意：

秦始皇要修路使得所有的城市连起来，并且花费最少；有一个人，叫徐福，他可以修一条魔法路，不花费任何的钱与劳动力。

秦始皇想让修路的费用最少，但是徐福想要受益的人最多，所以他们经过协商，决定让 A / B 最大，A代表被魔法路连接的两个城市的人口总数，B代表修的路中非魔法路的总长度。

输出 A / B 的最大值。

思路：

A / B 最大，则A尽可能大，B尽可能小，所以首先把MST求出来。由于每个城市的人口有很大的偏差，所以必须枚举每一条边，计算连接的两个城市的人口，复杂度为O(n^2)，所以每次替换边的复杂度必须是O(1)。

由于是稠密图，所以用prim算法，prim算法在O(n^2)的复杂度的时候，可以维护最小生成树上两点之间的最长边，这样就可以在过程中把两点间的最长边保存下来。这个是依靠已知的前驱节点实现的。复杂度为O(n^2)。

枚举每一条边时，如果这条边是MST中的边，那么就直接计算 A / B；如果这条边不在MST中，加入这条边就会成环，这时我们保存的信息就起作用了，成环之后把在MST中的连接这两点的最长边去掉，就是新的生成树的权值，且保证了B尽可能小。替换的时间复杂度为O(1)。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <math.h>
using namespace std;
const int maxn = 1005;
double path[maxn][maxn];
double g[maxn][maxn];
double dis[maxn];
bool vis[maxn];
bool used[maxn][maxn];
int peo[maxn];
int pre[maxn];
double ans;
struct point
{
    int x,y;
}p[maxn];

double cal(int i,int j)
{
    double x2 = (p[i].x - p[j].x) * (p[i].x - p[j].x);
    double y2 = (p[i].y - p[j].y) * (p[i].y - p[j].y);
    
    return sqrt(x2 + y2);
}

int prim(int n)
{
    memset(vis,0,sizeof(vis));
    memset(path,0,sizeof(path));
    memset(used,0,sizeof(used));
    for (int i = 0;i <= n;i++) dis[i] = 1e15;
    
    vis[1] = 1;
    dis[1] = 0;
    
    int tot = 0;
    ans = 0;
    //double len = 0;
    
    for (int i = 2;i <= n;i++)
    {
        pre[i] = 1;
        dis[i] = g[1][i];
    }
    
    for (int i = 1;i < n;i++)
    {
        int u;
        double d = 1e15;
        
        for (int j = 1;j <= n;j++)
        {
            if (!vis[j] && dis[j] < d)
            {
                d = dis[j];
                u = j;
            }
        }
        
        vis[u] = 1;
        
        ans += d;
        
        //tot = max(peo[u] + peo[pre[u]],tot);
        
        used[u][pre[u]] = used[pre[u]][u] = 1;
        
        for (int j = 1;j <= n;j++)
        {
            if (vis[j] && j != u)
                path[u][j] = path[j][u] = max(d,path[j][pre[u]]);
        }
        
        for (int j = 1;j <= n;j++)
        {
            if (!vis[j])
            {
                if (g[u][j] < dis[j])
                {
                    dis[j] = g[u][j];
                    pre[j] = u;
                }
            }
        }
    }
    
    //printf("%.2f **
",ans);
    
    return tot;
}

int main()
{
    int t;
    
    scanf("%d",&t);
    
    while (t--)
    {
        int n;
        
        scanf("%d",&n);
        
        for (int i = 1;i <= n;i++)
        {
            scanf("%d%d%d",&p[i].x,&p[i].y,&peo[i]);
        }
        
        for (int i = 1;i <= n;i++)
        {
            for (int j = 1;j <= n;j++)
            {
                g[i][j] = 1e15;
            }
        }
        
        for (int i = 1;i <= n;i++)
        {
            for (int j = i+1;j <= n;j++)
            {
                g[i][j] = g[j][i] = cal(i,j);
            }
        }
        
        prim(n);
        
        double ans1 = 0;
        
        for (int i = 1;i <= n;i++)
        {
            for (int j = i + 1;j <= n;j++)
            {
                if (used[i][j])
                {
                    int peop = peo[i] + peo[j];
                    ans1 = max(peop / (ans - g[i][j]),ans1);
                    
                    //printf("%d %d %d %.2f **
",i,j,peop,ans - g[i][j]);
                }
                else
                {
                    int peop = peo[i] + peo[j];
                    ans1 = max(peop / (ans - path[i][j]),ans1);
                    //printf("%d %d %d %.2f **
",i,j,peop,ans - path[i][j]);
                }
            }
        }
        
        printf("%.2f
",ans1);
        
        //printf("%.2f",path[1][4]);
    }
    
    return 0;
}