LA 5717枚举+最小生成树回路性质

/*LA 5717
《训练指南》P343
最小生成树的回路性质
在生成的最小生成树上，新增一条边e(u,v)
若原图上u到v的路径的最大边大于e，则删除此边，加上e，否则不变。

若原图上u到v的路径的最大边的产生：BFS/DFS都可 ，nm的复杂度，从每个点出发，找到每条边，更新最大即可
*/

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<cmath>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define LL unsigned long long
#define maxn 1010
#define INF 99999
using namespace std;

double X[maxn];
double Y[maxn];
int Peo[maxn];
int p[maxn];
double L;//最小生成树总长度
double MaxDis[maxn][maxn];
int n,cnt;

double nextnum()
{
    double x;
    scanf("%lf",&x);
    return x;
}
int nextint()
{
    int x;
    scanf("%d",&x);
    return x;
}

struct Edge
{
    double u,v,dis;
    bool operator<(const Edge&x)const
    {
        return dis<x.dis;
    }
    void print()
    {
        cout<<"u="<<u<<","<<"v="<<v<<","<<"dis="<<dis<<endl;
    }
} e[maxn*maxn];

vector<Edge>edges;//存储新图的边
vector<int>G[maxn];//记录临街的边号

double Dis(int i,int j)
{
    double x1=X[i],x2=X[j],y1=Y[i],y2=Y[j];
    return (sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)));
}

int findx(int x)
{
    if (p[x]==x) return x;
    else return p[x]=findx(p[x]);
}

void merge(int x,int y)
{
    int px=findx(x);
    int py=findx(y);
    p[px]=py;
}

void init()
{
    cin>>n;
    cnt=0;L=0;
    for(int i=1; i<=n; i++)
    {
        X[i]=nextnum();//坐标值实数
        Y[i]=nextnum();
        Peo[i]=nextint();
    }
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
        {
            if (i==j) continue;
            e[cnt++]=(Edge){i,j,Dis(i,j)};//建图
        }
}

void prim()//最小生成树&&构建新的图
{
    for(int i=1;i<=n;i++) G[i].clear();
    edges.clear();
    for(int i=1; i<=n; i++) p[i]=i;
    sort(e,e+cnt);

    for(int i=0; i<cnt; i++)
    {
        int u=e[i].u,v=e[i].v;
        double dis=e[i].dis;
        int pu=findx(u),pv=findx(v);
        if (pu==pv) continue;
        L+=dis;
        merge(u,v);
        edges.push_back((Edge){u,v,dis});
        G[u].push_back(edges.size()-1);
        edges.push_back((Edge){v,u,dis});
        G[v].push_back(edges.size()-1);

        if (edges.size()==2*(n-1)) break;
    }
}
typedef pair<int,double> Node;//<上一个点，由起点到上一个点的通路上的最大值>
void max_dis()//找到最小生成树上的任意两点之间的通路的最大的边的长度，网上大多数版本是DFS实现，故写了BFS
{
    memset(MaxDis,0,sizeof(MaxDis));
    bool mark[maxn];
    for(int i=1;i<=n;i++)
    {
        memset(mark,0,sizeof(mark));
        queue<Node>Q;
        Q.push(make_pair(i,0));
        while(!Q.empty())
        {
            Node Kn=Q.front();Q.pop();
            int u=Kn.first;double dis=Kn.second;
            if (mark[u]) continue;
            mark[u]=true;
            int m=G[u].size();
            for(int j=0;j<m;j++)
            {
                Edge e=edges[G[u][j]];
                int v=e.v;
                if (MaxDis[i][v]>0) continue;//important，小技巧，因为存的是双向边，所以必须消除回退的影响
                dis=MaxDis[i][v]=max(Dis(u,v),dis);
                Q.push(make_pair(v,dis));
            }
        }
    }
}

int main()
{
    int cas=0;
    cin>>cas;
    while(cas--)
    {
        init();
        prim();
        max_dis();
        double ans=0;
        for(int i=2; i<=n; i++)//枚举每一条道路
            for(int j=1; j<i; j++)
            {
                int A=Peo[i]+Peo[j];
                double B=L-MaxDis[i][j];
                ans=max(ans,A/B);
            }
        printf("%.2lf\n",ans);
    }
    return 0;
}