BZOJ 1050 [HAOI2006]旅行comf(并查集)

1050: [HAOI2006]旅行comf

Description

给你一个无向图，N(N<=500)个顶点, M(M<=5000)条边，每条边有一个权值Vi(Vi<30000)。给你两个顶点S和T，求

一条路径，使得路径上最大边和最小边的比值最小。如果S和T之间没有路径，输出”IMPOSSIBLE”，否则输出这个

比值，如果需要，表示成一个既约分数。 备注： 两个顶点之间可能有多条路径。

Input

第一行包含两个正整数，N和M。下来的M行每行包含三个正整数：x，y和v。表示景点x到景点y之间有一条双向公路

，车辆必须以速度v在该公路上行驶。最后一行包含两个正整数s，t，表示想知道从景点s到景点t最大最小速度比

最小的路径。s和t不可能相同。

1<N<=500,1<=x,y<=N，0<v<30000，0<M<=5000

Output

如果景点s到景点t没有路径，输出“IMPOSSIBLE”。否则输出一个数，表示最小的速度比。

如果需要，输出一个既约分数。

Sample Input

【样例输入1】
4 2
1 2 1
3 4 2
1 4
【样例输入2】
3 3
1 2 10
1 2 5
2 3 8
1 3
【样例输入3】
3 2
1 2 2
2 3 4
1 3

Sample Output

【样例输出1】
IMPOSSIBLE
【样例输出2】
5/4
【样例输出3】
2

思路：

看到题最先蹦出来的想法是用Dijkstra或SPFA，把每次更新的条件稍微改一下，跑一遍。

但后来发现，本题求的路径其实只与最长边和最短边有关系，也就说明，一旦确定的最长和最短边，任何边权在这个范围之中的边都可以任意加入，不影响结果。那就差不多有了一个类似于kruskal的做法，将边排序后，从小到大枚举最小边。对于每个最小边，按从小到大顺序加入每条边，用并查集维护图的连通性，直到某次加入一条边后s，t连通。

但这是一个O(m^2)的算法，对于m<=5000是过不去的。思考这个算法，发现，算法有很大一部分时间浪费在了没用的边上。对于每次枚举得到的答案，最短边l可能对此时图的连通性没有影响，那么这个最短边l是没必要进行一次运算的。那我们要怎么判断这个最短边l是否有用呢?假设从最短边l开始运算，我们已经得到的最长边r，那么反过来做一遍就可以得到边权最大的最短边。也就是在从最长边向最短边运算的时候，一旦在加入某条边i后，s，t连通了，那么这个i是最大的，需要最大边r的最小边。也就是说，在原来的[l,r]的边中，其实[l,i)这些边可以不取，仅靠[i,r]就可以把原图连通了。那么，在最大边确定的情况下，最小边的边权越大越好，有选i为最小边优于选[l,i)中的边为最短边。下次就可以直接从i+1开始运算。

因此，核心部分步骤大致如下：

初始化并查集->从l开始找到能使s,t 连通的最短最大边r->初始化并查集->  从r开始找到能使s,t 连通的最长最小边i->更新答案。

总之，并查集真是个好东西啊...

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
const int MAXN=550,MAXM=5050;
struct edge
{
	int u,v,w;
}E[MAXM];
bool cmp(edge a,edge b)
{
	return a.w<b.w;
}
int read()
{
	char c;
	int rtn=0;
	c=getchar();
	while(c<'0'||c>'9')c=getchar();
	while(c>='0'&&c<='9'){rtn=rtn*10+c-'0';c=getchar();}
	return rtn;
}
int gcd(int a,int b)
{
	return b==0?a:gcd(b,a%b);
}
int n,m,s,t,u,v,w;
int ansmx,ansmn;
double ans;
int fa[MAXN];
bool p;
int find(int x)
{
	return x==fa[x]?x:fa[x]=find(fa[x]);
}
void init()
{
	n=read();m=read();
	for(int i=1;i<=m;i++)
	{
		E[i].u=read();
		E[i].v=read();
		E[i].w=read();
	}
	sort(E+1,E+m,cmp);
	s=read();t=read();
}
void work()
{
	int l=1,r;p=0;ans=MAXM;
	while(l<=m)
	{
		int mn=-1,mx=-1;
		for(int i=1;i<=n;i++)fa[i]=i;
		for(r=l;r<=m;r++)
		{
			fa[find(E[r].u)]=find(E[r].v);
			if(find(s)==find(t))
			{mx=E[r].w;break;}
		}
		if(mx==-1)break;
		for(int i=1;i<=n;i++)fa[i]=i;
		for(l=r;l>=1;l--)
		{
			fa[find(E[l].u)]=find(E[l].v);
			if(find(s)==find(t))
			{mn=E[l].w;break;}
		}
		if(mn==-1)break;
		double nw=double(mx)/double(mn);
		if(nw<ans){ansmx=mx;ansmn=mn;ans=nw;}
		l++;
	}
}
void output()
{
	int d=gcd(ansmx,ansmn);
	if(ans==MAXM)cout<<"IMPOSSIBLE\n";
	else if(ansmn==d)cout<<ansmx/d<<endl;
	else cout<<ansmx/d<<'/'<<ansmn/d<<endl;
}
int main()
{
	init();
	work();
	output();
	return 0;
}