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

很难想到怎么暴力的一个暴力（看来我还是太弱QAQ），枚举边权最小的一个边，然后不停的加边，直到 s 与 t 联通 ， 那当前加的边与枚举的最小边就是一组解，遍历一遍取最优解即可，答案拿gcd搞一下就好。
代码如下

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
const int size = 200010;
int tot;
struct gtnd
{
    int f,t;
    ll d;
    bool operator < (const gtnd &a)const
    {
        return d < a.d;
    }
}l[size];
void build(int f,int t,int d)
{
    tot ++;
    l[tot].f = f;
    l[tot].t = t;
    l[tot].d = d;
}
int n,m,s,t;
int f[size];
int find(int x)
{
    if(f[x] == x)
        return x;
    return f[x] = find(f[x]);
}
int read()
{
    int x = 0 , f = 1;
    char in = getchar();
    while(in < '0' || in > '9')
    {
        if(in == '-')
            f = -1;
        in = getchar();
    }
    while(in >= '0' && in <= '9')
    {
        x = (x << 3) + (x << 1) + in - '0';
        in = getchar();
    }
    return x * f;
}
void start()
{
    n = read() , m = read();
    for(int i = 1 ; i <= m ; i ++)
    {
        int x = read() , y = read() , v = read();
        build(x,y,v);
    }
    s = read() , t = read();
    sort(l+1,l+tot+1);
}
void init()
{
    for(int i = 1 ; i <= n ; i ++)
        f[i] = i;
}
int gcd(int a,int b)
{
    if(b == 0)
        return a;
    return gcd(b,a%b);
}
int main()
{
    start();
    ll ans_minn = 1 , ans_maxn = 2147483641;
    for(int i = 1 ; i <= m ; i ++)
    {
        init();
        f[find(l[i].f)] = find(l[i].t);
        ll now_maxn = l[i].d;
        bool flag = 0;
        for(int j = i ; j <= m ; j ++)
        {
            int fj = find(l[j].f) , tj = find(l[j].t);
            if(fj != tj)
            {
                now_maxn = l[j].d;
                f[fj] = tj;
            }
            if(find(s) == find(t))
            {
                flag = 1;
                break;
            }

        }
        if(flag && ans_maxn * l[i].d > ans_minn * now_maxn)
        {
            ans_maxn = now_maxn;
            ans_minn = l[i].d;
        }
    }
    if(ans_maxn == 2147483641)
        puts("IMPOSSIBLE");
    else
    {
        if(ans_maxn % ans_minn == 0)
            printf("%lld\n",ans_maxn/ans_minn);
        else
        {
            int temp = gcd(ans_maxn,ans_minn);
            while(temp != 1)
            {
                ans_maxn /= temp;
                ans_minn /= temp;
                temp = gcd(ans_maxn,ans_minn);
            }
            printf("%lld/%lld\n",ans_maxn,ans_minn);
        }
    }
    return 0;
}