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

枚举+并查集：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<algorithm>
#define INF 0x3f3f3f
using namespace std;
int set[500+10];
struct line
{
    int start,end,speed;
}num[5000+10];
bool cmp(line a,line b)
{
    return a.speed<b.speed;
}
int find(int p)
{
    int child=p;
    int t;
    while(p!=set[p])
    p=set[p];
    while(child!=p)
    {
        t=set[child];
        set[child]=p;
        child=t;
    }
    return p;
}
void merge(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
    set[fx]=fy;
}
int gcd(int a,int b)
{
    int t;
    while(a)
    {
        t=a;
        a=b%a;
        b=t; 
    }
    return b;
}
int main()
{
    int t,n,m,i,j;
    int s,e;//起点终点
    int min,max;//最小速度,最大速度
    double best;//最优比例 
    int bestmin,bestmax;//最优条件下的最小速度，最大速度
    int exist;//连通判断 
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&num[i].start,&num[i].end,&num[i].speed);
        }
        sort(num,num+m,cmp);
        scanf("%d%d",&s,&e);
        best=INF;
        for(i=0;i<m;i++)
        {
            for(j=1;j<=n;j++)
            {
                set[j]=j;//初始化 
            }
            exist=0;//判断是否连通，连通为 1 
            min=num[i].speed;//记录最小速度
            for(j=i;j<m;j++)
            {
                merge(num[j].start,num[j].end);
                max=num[j].speed;//已经按速度升序排列过了
                if(find(s)==find(e))//连通起点终点 
                {
                    exist=1;
                    break;
                } 
            } 
            if(exist)
            {
                if(((double)max/(double)min)<best)//每次更新
                {
                    best=(double)max/(double)min;
                    bestmax=max;
                    bestmin=min;
                } 
            }
        }
        if(best!=INF)
        {
            if(bestmax%bestmin==0)
            printf("%d\n",bestmax/bestmin);
            else
            printf("%d/%d\n",bestmax/gcd(bestmax,bestmin),bestmin/gcd(bestmax,bestmin));
        }
        else
        printf("IMPOSSIBLE\n");
    } 
    return 0;
}