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

来源

第六届河南省程序设计大赛

刚看到到连通问题就想到了并查集但又涉及到了速度就自然联想到了最短路，按照图论思维最终还是想不通

其实求比值大小，时间有5秒完全可以暴力枚举啊，心塞了好长时间，通过这道题加深了我对并查集意义的理解，而不仅仅是停留在套模版的层面了

#include <iostream>
#include <algorithm>
using namespace std;
const int N=5011;
int father[N];
#define INF 0x3fffffff
struct node
{
    int x, y, v;
}p[N];
bool cmp(node a,node b)
{
    return a.v>b.v;
}
void initl(int n)
{
    for(int i=0;i<n;i++)
    {
        father[i]=i;
    }
    return ;
}
int Find(int x)
{
    if(x!=father[x])
    {
        father[x]=Find(father[x]);
    }
    return father[x];
}
void Union(int p,int q)
{
    p=Find(p),q=Find(q);
    if(p>q)
    {
        father[p]=q;
    }
    else
    {
        father[q]=p;
    }
}
int gcd(int a,int b)
{
    int r=a%b;
    while(r!=0)
    {
        a=b;
        b=r;
        r=a%b;
    }
    return b;
}


int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n, m, s, e, i, j, aa, bb;
        cin>>n>>m;
        for(int i=0;i<m;i++)
        {
            cin>>p[i].x>>p[i].y>>p[i].v;
        }
        cin>>s>>e;
        sort(p,p+m,cmp);
        double flag=INF*1.0;
        for(i=0;i<m;i++)
        {
            initl(n);
            for(j=i;j<m;j++)
            {
                if(Find(p[j].x)!=Find(p[j].y))
                {
                    Union(p[j].x,p[j].y);
                }
                if(Find(s)==Find(e))
                {
                    break;
                }
            }
            if(j==m)
            {
                break;
            }
            int fenz=p[i].v, fenm=p[j].v;
            double f=(1.0)*fenz/fenm;
            if(f<flag)
            {
                aa=fenz, bb=fenm;
                flag=(1.0)*fenz/fenm;//注意数据类型
            }
        }
        if(flag==INF)
        {
            cout<<"IMPOSSIBLE"<<endl;
        }
        else
        {
            if(aa%bb==0)//题目
            {
                cout<<flag<<endl;
            }
            else
            {
                cout<<aa/(gcd(aa,bb))<<"/"<<bb/(gcd(aa,bb))<<endl;
            }
        }
    }
    return 0;
}