Qin Shi Huang‘s National Road System HDU - 4081 （次小生成树）

二次做这道题了 上一次照着题解写的
基本上思路忘光了
这次花了挺久时间才把这题弄得差不多懂
还一直tle re 最后莫名其妙的a了
就感觉很神奇 有些时候g++交过不了 c++交就过得了
有的时候c++过不了 g++有过的了
就听迷惑的

题目思路

题目要求的是魔法边连接的两个点的点权和除上所有点连在一起的边权和
边权和不包括魔法边的边权
我们设分子为A 分母为B
我们要的是让A越大越好 B越小越好
对于答案 我们可以枚举每条边做魔法边时的值
先求出最小生成树的值ans 然后枚举边的时候判断边是否在最小生成树上
1.如果在那么B就直接可以变成ans-该边边权
2.如果不在那么B的值就需要处理一下
因为该边不在最小生成树上
如果加上这条边 就会成环
所以我们要在建树的时候 记录每个点之间的最大值
这样我们求B的值就可以变成
ans-该边所连接的两个点在最小生成树上的最大边权
然后更新最大值 最后输出

其实除了这种思路还有别的思路
因为我们最后减的边权一定是在最小生成树上
所以我们只枚举最小生成树上的边
然后我们对去除这条边之后形成的两个点集合枚举每个点集合中最大的点权
然后将这两个的点之间建魔法边 然后按照公式求值就好

ac代码

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <vector>
#include <stack>
#include <queue>
#include  <map>
#include <set>
#include <utility>
#define pi 3.1415926535898
#define ll long long
#define lson rt<<1
#define rson rt<<1|1
#define eps 1e-6
#define ms(a,b) memset(a,b,sizeof(a))
#define legal(a,b) a&b
#define print1 printf("111\n")
using namespace std;
const int maxn = 1000+50;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
const ll mod = 1000000007;
//998244353
int f[maxn],a[maxn],vis[maxn];

struct point
{
    int x,y;
}t[maxn*maxn];

struct node
{
    int x,y;
    double w;
}e[maxn*maxn];
vector<int>vec[maxn];
double dis[maxn][maxn];
int findx(int x)
{
    return f[x]==x?f[x]:f[x]=findx(f[x]);
}

bool cmp(const node &a,const node &b)//这个地方挺迷的 只写node会t掉
{
    return a.w<b.w;
}

double calc(int x,int y)
{
    return sqrt((t[x].x-t[y].x)*(t[x].x-t[y].x)+(t[x].y-t[y].y)*(t[x].y-t[y].y));
}

int main()
{
    int _;
    scanf("%d",&_);
    while(_--)
    {
        int n,len=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)f[i]=i,vis[i]=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d",&t[i].x,&t[i].y,&a[i]);
            vec[i].push_back(i);
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=i+1;j<=n;j++)
            {
                double tem=calc(i,j);
                e[++len].x=i;
                e[len].y=j;
                e[len].w=tem;
                
            }
        }
        sort(e+1,e+1+len,cmp);
        int num=0;
        double tem1=0;
        //for(int i=1;i<=len;i++)vis[i]=0;
        for(int i=1;i<=len;i++)
        {
            int r1=findx(e[i].x);
            int r2=findx(e[i].y);
            if(r1!=r2)
            {
                int len_a=vec[r1].size(),len_b=vec[r2].size();
                tem1+=e[i].w;
                num++;
                vis[i]=1;
                f[r1]=r2;
                for(int k=0;k<len_a;k++)
                {
                    for(int j=0;j<len_b;j++)
                    {
                        dis[vec[r1][k]][vec[r2][j]]=dis[vec[r2][j]][vec[r1][k]]=e[i].w;//记录更新点之间的最大边权 因为kruscal对边权排过序 所以不用担心后面的值小于前面的
                    }
                }
                for(int j=0;j<len_a;j++)
                    vec[r2].push_back(vec[r1][j]);//合并集合
                if(num==n-1)
                {
                    break;
                }
            }

        }
        //printf("%lf\n",tem1);
        double ans=0;
        for(int i=1;i<=len;i++)
        {
                //判断情况分别求值
                if(vis[i]==1)
                    ans=max(ans,(a[e[i].x]+a[e[i].y])*1.0/(tem1-e[i].w));
                else
                    ans=max(ans,(a[e[i].x]+a[e[i].y])*1.0/(tem1-dis[e[i].x][e[i].y]));

       }
       printf("%.2lf\n",ans);
       for(int i=1;i<=n;i++)vec[i].clear();
    }

}