hdu 4081 Qin Shi Huang's National Road System

https://vjudge.net/problem/HDU-4081

题意：

秦始皇想要修长城，修成生成树的样子，这是一个大师出现了，他说他可以不耗费人力修出一条路来。他们的目的很不一样，神特么有分歧，最后他们达成了一个协议，假设一个城市的人口为a。那么最后不耗费人力修的那条路所相连的两个城市的人口之和A与修路花费的人力B之比 A/B最大，并且输出最大值。

思路：

枚举去掉每一条边。

首先求出最小生成树，对于最小生成树中的每一条边，如果这条边不花费人力，那么直接计算A和B就可以了。

那么问题是如果选择的边不在最小生成树中的话，应该怎么办。为了形成生成树，肯定要将最小生成树生成树中的边去掉，又为了保持边的权值之和是最小的，所以自然想到了次小生成树，用到了maxn[u][v]那个数组，所以就将maxn[u][v]减去进行比较就行了。maxn[u][v]的求法请见次小生成树学习的博文。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <vector>
#include <queue>
using namespace std;

struct node
{
    int x,y;
    double len;
} a[1000005];

struct com
{
    int id;
    double dis;
};

int h[1005],z[1005],p[1005];
int par[1005];
bool v[1000005];
double ma[1005][1005];
bool vis[1005];
vector<node> no[1005];

bool cmp(node aa,node bb)
{
    if (aa.len == bb.len)
    {
        double t1 = p[aa.x] + p[aa.y];
        double t2 = p[bb.x] + p[bb.y];

        return t2 < t1;
    }

    return aa.len < bb.len;
}

void init(int n)
{
    for (int i = 0;i < n;i++)
        par[i] = i;
}

int fin(int x)
{
    if (x == par[x]) return x;
    else return par[x] = fin(par[x]);
}

void unit(int x,int y)
{
    x = fin(x);
    y = fin(y);

    if (x != y) par[x] = y;
}

double cal(int i,int j)
{
    double dis1 = 1.0 * (h[i] - h[j]) * (h[i] - h[j]);
    double dis2 = 1.0 * (z[i] - z[j]) * (z[i] - z[j]);

    return sqrt(dis1 + dis2);
}

void adde(int x,int y,double dis)
{
    node t;

    t.x = x;
    t.y = y;
    t.len = dis;

    no[x].push_back(t);
}

void bfs(int k)
{
    memset(vis,0,sizeof(vis));

    com now,nex;

    queue<com> qq;

    while (!qq.empty()) qq.pop();

    now.id = k;now.dis = 0;
    vis[now.id] = 1;

    qq.push(now);

    while (!qq.empty())
    {
        com tc = qq.front();qq.pop();

        int tx = tc.id;
        double maxn = tc.dis;

        for (int i = 0;i < no[tx].size();i++)
        {
            node tmp = no[tx][i];
            int ty = tmp.y;
            double tmaxn = tmp.len;

            if (!vis[ty])
            {
                vis[ty] = 1;
                nex.id = ty;
                nex.dis = tmaxn;

                if (maxn > tmaxn) nex.dis = maxn;

                ma[k][ty] = nex.dis;

                qq.push(nex);
            }
        }
    }
}

int main()
{
    int t;

    scanf("%d",&t);

    while (t--)
    {
        int n;

        scanf("%d",&n);

        init(n);
        memset(a,0,sizeof(a));
        memset(v,0,sizeof(v));
        memset(no,0,sizeof(no));

        for (int i = 0;i < n;i++)
        {
            scanf("%d%d%d",&h[i],&z[i],&p[i]);
        }

        int cnt = 0;

        for (int i = 0;i < n;i++)
            for (int j = i + 1;j < n;j++)
        {
            a[cnt].x = i;a[cnt].y = j;
            a[cnt].len  = cal(i,j);
            cnt++;
        }

        double es = 0;

        sort(a,a+cnt,cmp);

        for (int i = 0;i < cnt;i++)
        {
            int x = a[i].x,y = a[i].y;

            if (fin(x) == fin(y)) continue;

            unit(x,y);

            v[i] = 1;

            adde(x,y,a[i].len);
            adde(y,x,a[i].len);

            es += a[i].len;
        }

        double maxn = 0;

        for (int i = 1;i <= n;i++)
        {
            bfs(i);
        }

        for (int i = 0;i < cnt;i++)
        {
            if (v[i])
            {
                double ns = 0;
                int x = a[i].x,y = a[i].y;

                ns += p[x];ns += p[y];

                es -= a[i].len;

                if (ns / es > maxn) maxn = ns / es;

                es += a[i].len;
            }
            else
            {
                double ns = 0;
                int x = a[i].x,y = a[i].y;

                ns += p[x];ns += p[y];

                es -= ma[x][y];

                if (ns / es > maxn) maxn = ns / es;

                es += ma[x][y];
            }
        }

        printf("%.2f
",maxn);
    }

    return 0;
}