NYOJ 711 最舒适的路线

最舒适的路线

时间限制： 5000 ms  |  内存限制： 65535 KB

难度： 5

描述

异形卵潜伏在某区域的一个神经网络中。其网络共有N个神经元（编号为1,2,3,…,N），这些神经元由M条通道连接着。两个神经元之间可能有多条通道。异形卵可以在这些通道上来回游动，但在神经网络中任一条通道的游动速度必须是一定的。当然异形卵不希望从一条通道游动到另一条通道速度变化太大，否则它会很不舒服。

现在异形卵聚居在神经元S点，想游动到神经元T点。它希望选择一条游动过程中通道最大速度与最小速度比尽可能小的路线，也就是所谓最舒适的路线。

输入

第一行： K 表示有多少组测试数据。 
接下来对每组测试数据：
第1行: N M
第2~M+1行： Xi Yi Vi (i=1,…..,M)
表示神经元Xi 到神经元Yi之间通道的速度必须是Vi
最后一行： S T ( S  T )

【约束条件】
2≤K≤5 1<N≤500 0<M≤5000 1≤ Xi, Yi , S , T ≤N 0< Vi <30000，
Vi是整数。数据之间有一个空格。

输出

对于每组测试数据，输出一行：如果神经元S到神经元T没有路线，输出“IMPOSSIBLE”。否则输出一个数，表示最小的速度比。如果需要，输出一个既约分数。

样例输入

2

3 2

1 2 2

2 3 4

1 3

3 3

1 2 10

1 2 5

2 3 8

1 3

样例输出

2

5/4

思路，并查集，排序。先将边由大到小排序，然后使用并查集依次加入边，直到find(S)==find(T)即s可以到达t，然后记录最大边max和最小边min。

第二步将第一条边去除后再进行以上步骤。找出最小的max/min即为答案。

#include<stdio.h>
#include<algorithm>
using namespace std;
int p[510];
int find(int x)
{
	if(x!=p[x])
	{
		p[x]=find(p[x]);
	}
	return p[x];
}
void bin(int x,int y)
{
	int a,b;
	a=find(x);
	b=find(y);
	if(a!=b)
	  p[a]=b;
}
struct Node
{
	int x;
	int y;
	int z;
}node[5010];
int comp(Node n1,Node n2)
{
	return n1.z>n2.z;
}
void solve(int max,int min)
{
	if(max%min==0)
	{
		printf("%d\n",max/min);
		return ;
	}
	int t,a=max,b=min;
	while(b!=0)
	{
		t=a%b;
		a=b;
		b=t;
	}
	max/=a;
	min/=a;
	printf("%d/%d\n",max,min);
}
int main()
{
	int t,i,j,n,m,max,min,a,b,S,T,mark;
	scanf("%d",&t);
	while(t--)
	{
		max=30000;
		min=1;
		mark=0;
		scanf("%d%d",&n,&m);
		for(i=0;i<m;i++)
			scanf("%d%d%d",&node[i].x,&node[i].y,&node[i].z);
		scanf("%d%d",&S,&T);
		sort(node,node+m,comp);
		for(i=0;i<m;i++)
		{
			for(j=1;j<=n;j++)
				p[j]=j;
			a=node[i].z;
			for(j=i;j<m;j++)
			{
				bin(node[j].x,node[j].y);
				if(find(S)==find(T))
				{
					b=node[j].z;
					break;
				}
			}
			if(j==m)
			{
				mark=1;
				break;
			}
			if(max/(min*1.0)>a/(b*1.0))
			{
				max=a;
				min=b;
			}
		}
		if(mark==1 && max/min==30000)
			printf("IMPOSSIBLE\n");
		else
		    solve(max,min);
	}
	return 0;
}
/*
1
4 4
1 2 4
1 4 5
2 3 3
3 4 4
1 3
*/