Qin Shi Huang's National Road System HDU - 4081（生成树问题）

题目链接

大意：给出N个点的坐标以及每个点的人口, 要求将这N个点通过N-1条边连接起来, 权值为两点直接距离, B为距离和, 同时可以选中一条边, 使得该边权值变为0, A为该边两点人口数量. 求A/B的最大值。

思路：
为了使的A/B值最大，首先是需要是B尽量要小，所以可先求出n个城市的最小生成树。然后，就是决定要选择那一条用徐福的魔法来变。
因此，可以枚举每一条边，假设最小生成树的值是MinMST, 而枚举的那条边长度是w[i][j], 如果这一条边已经是属于最小生成树上的，那么最终式子的值是A/(MinMST-w[i][j])。如果这一条不属于最小生成树上的， 那么添加上这条边，就会有n条边，那么就会使得有了一个环，为了使得它还是一个生成树，就要删掉环上的一棵树。 为了让生成树尽量少，那么就要删掉除了加入的那条边以外，权值最大的那条路径。 假设删除的那个边的权值是path[i][j],那么就是A/(MinMST-path[i][j])。
可以看到, 虽然这里没有直接使用次小生成树, 但是完全用到了次小生成树求出的几个数组, 这也是前面为何没有直接求出次小生成树的原因, 因为大部分的题目必然不是裸题, 所以更要仔细理解次小生成树的思想。

这题两种Kruskal和Prim都可以用。我只用了Kruskal，因为我还没学过Prim。蒟蒻哭泣。

Kruskal代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cmath>
#define maxn 1050

using namespace std;

struct node{
	int u,v;
	double w;
	bool vis;
}edge[maxn*maxn];

vector<int> p[maxn];
int n,cnt,tot;
double ans;
int s[maxn],pe[maxn],x[maxn],y[maxn];
double maps[maxn][maxn];

void init(){
	cnt=tot=ans=0;
	for(int i=0;i<maxn;i++){
		s[i]=i;
		p[i].clear();
		p[i].push_back(i);
	}
}

int find(int u){
	return s[u]==u?u:find(s[u]);
}

bool cmp(const node &a,const node &b){
	return a.w<b.w;
}

void Kruskal(){
	sort(edge,edge+cnt,cmp);
	for(int i=0;i<cnt;i++){
		int a=find(edge[i].u);
		int b=find(edge[i].v);
		if(a!=b){
			ans+=edge[i].w;
			edge[i].vis=true;
			s[b]=a;
			tot++;
			for(int j=0;j<p[a].size();j++){
				for(int k=0;k<p[b].size();k++){
					maps[p[a][j]][p[b][k]]=maps[p[b][k]][p[a][j]]=edge[i].w;
				}
			}
			for(int j=0;j<p[b].size();j++){
				p[a].push_back(p[b][j]);
			}
		}
		if(tot==n-1){
			break;
		} 
	}
}

int main(){
//	freopen("in.txt","r",stdin);
	int t;
	scanf("%d",&t);
	while(t--){
		init();
		scanf("%d",&n);
		for(int i=0;i<n;i++){
			scanf("%d%d%d",&x[i],&y[i],&pe[i]);
		}
		for(int i=0;i<n;i++){
			for(int j=i+1;j<n;j++){
				double temp=(double)sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
				edge[cnt].u=i;
				edge[cnt].v=j;
				edge[cnt].w=temp;
				edge[cnt++].vis=false;
			}
		}
		Kruskal();
		double res=-100000;
		for(int i=0;i<cnt;i++){
			if(edge[i].vis){
				res=max(res,(double)(pe[edge[i].u]+pe[edge[i].v])/(ans-edge[i].w));
			}else{
				res=max(res,(double)(pe[edge[i].u]+pe[edge[i].v])/(ans-maps[edge[i].u][edge[i].v]));
			}
		}
		printf("%.2lf\n",res);
	}
	return 0;
} 

Prim版本
参考博客

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
#define maxn 1050

using namespace std;

typedef pair<double,int> Pii; 

struct node{
	int next,to;
	double w;
}edge[maxn*maxn];

int n,cnt,tot;
double ans;
int head[maxn],x[maxn],y[maxn],pe[maxn],s[maxn];//s记录父亲节点 
double maps[maxn][maxn],dis[maxn];//dis记录的是最小生成树的枝干，maps记录的是从u->v点的最大距离 
bool vis[maxn],mst[maxn][maxn];//mst记录是否在最小生成树上 

void init(){
	cnt=tot=0;
	ans=0;
	memset(maps,0,sizeof maps);
	memset(head,-1,sizeof head);
	fill(dis,dis+maxn,inf);
	memset(vis,false,sizeof vis);
	memset(mst,false,sizeof mst);
	fill(s,s+maxn,1);//这里与Kruskal不同，要先把所有结点指向第一个入队的结点 
	for(int i=0;i<maxn*maxn;i++){
		edge[i].next=-1;
	}
}

void add(int u,int v,double w){
	edge[tot].to=v;
	edge[tot].w=w;
	edge[tot].next=head[u];
	head[u]=tot++;
}

void Prim(){
	priority_queue<Pii> que;
	dis[1]=0;
	que.push(Pii(-dis[1],1));
	while(!que.empty()&&cnt<n){
		Pii p=que.top();
		que.pop();
		int now=p.second;
		if(vis[now]){
			continue;
		}
		cnt++;
		ans+=-p.first;
		vis[now]=true;
		mst[now][s[now]]=mst[s[now]][now]=true;
		for(int i=head[now];i!=-1;i=edge[i].next){
			if(vis[edge[i].to]){
				maps[now][edge[i].to]=maps[edge[i].to][now]=max(maps[s[now]]/[edge[i].to],dis[now]);//maps数组用到了dp的思想
			}
			if(dis[edge[i].to]>edge[i].w){
				s[edge[i].to]=now;
				dis[edge[i].to]=edge[i].w;
				que.push(Pii(-dis[edge[i].to],edge[i].to));				
			}
		}
	}
}

int main(){
	int t;
	scanf("%d",&t);
	while(t--){
		init();
		scanf("%d",&n);
		for(int i=1;i<=n;i++){
			scanf("%d%d%d",&x[i],&y[i],&pe[i]);
		}
		for(int i=1;i<=n;i++){
			for(int j=i+1;j<=n;j++){
				double temp=(double)sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
				add(i,j,temp);
				add(j,i,temp);
			}
		}
		Prim();
		double res=-1;
		for(int i=1;i<=n;i++){
			for(int j=head[i];j!=-1;j=edge[j].next){
				if(mst[i][edge[j].to]){
					res=max(res,(double)(pe[i]+pe[edge[j].to])/(ans-edge[j].w));
				}else{
					res=max(res,(double)(pe[i]+pe[edge[j].to])/(ans-maps[i][edge[j].to]));
				}
			}
		}
		printf("%.2lf\n",res);
	}
	return 0;
}