codevs1001 舒适的路线

题目描述 Description

　　Z小镇是一个景色宜人的地方，吸引来自各地的观光客来此旅游观光。Z小镇附近共有N(1<N≤500)个景点（编号为1,2,3,…,N），这些景点被M（0<M≤5000）条道路连接着，所有道路都是双向的，两个景点之间可能有多条道路。也许是为了保护该地的旅游资源，Z小镇有个奇怪的规定，就是对于一条给定的公路R_i，任何在该公路上行驶的车辆速度必须为V_i。频繁的改变速度使得游客们很不舒服，因此大家从一个景点前往另一个景点的时候，都希望选择行使过程中最大速度和最小速度的比尽可能小的路线，也就是所谓最舒适的路线。

输入描述 Input Description

第一行包含两个正整数，N和M。
接下来的M行每行包含三个正整数：x，y和v（1≤x,y≤N，0 最后一行包含两个正整数s，t，表示想知道从景点s到景点t最大最小速度比最小的路径。s和t不可能相同。

输出描述 Output Description

如果景点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

数据范围及提示 Data Size & Hint

N(1<N≤500)

M（0<M≤5000）

Vi在int范围内

（转自[codevs1001]）

---

　　最开始（大概半年前吧），这道题也没想出来，直接去spfa，写到一半，发现有问题，一个点最大限速比最小限速最小，不能保证后面的点也是最小。

然后看题解，看了几个，都没看懂，只是知道了一件事，要用并查集。

　　现在重新来看这道题。通过并查集想到了最小（大）生成树。按照最大生成树来做，直到s和t连通。连通后可以发现当经过这条路上最大限速的这一条边的情况是最优的（因为这条路径上每一条边都尽可能大），但是不是整张图中最优的。怎么办？多算几条很优的线。把这条路径最大限速的那条边删掉（因为再保留这条边已经没有意义了，对于这条边来说已经是最优的了），更新答案，重新最大生成树。直到无论怎么加边s，t都不会连通的时候退出算法。

（貌似用最小生成树也行，不过删的那条边变成了最小限速），算法时间复杂度大概是O(m² + mn)（生成树上dfs，时间复杂度$O(n)$）

Code_{(超级不简洁的代码，其中前134行是模板，主要过程在167行以后)}

/**
 * codevs.cn
 * Problem1001
 * Accepted
 * Time:378ms
 * Memory:588k
 */ 
#include<iostream>
#include<sstream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<algorithm>
using namespace std;
typedef bool boolean;
#define smin(a, b) (a) = min((a), (b))
#define smax(a, b) (a) = max((a), (b))
template<typename T>
inline void readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-');
    if(x == '-'){
        aFlag = -1;
        x = getchar();
    }
    for(u = x - '0'; isdigit((x = getchar())); u = u * 10 + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

typedef class union_found{
    public:
        int points;
        int *f;
        union_found():f(NULL) {}
        union_found(int points):points(points){
            f = new int[(const int)(points + 1)];
            for(int i = 0; i <= points; i++)
                f[i] = i;
        }
        int find(int x) {
            if(f[x] != x)    return f[x] = find(f[x]);
            return f[x];
        }
        void unit(int fa, int so) {
            int ffa = find(fa);
            int fso = find(so);
            f[fso] = ffa;
        }
        boolean connected(int a, int b) {
            return find(a) == find(b);
        }
        void clean(){
            for(int i = 0; i <= points; i++)
                f[i] = i;
        }
}union_found;

///map template starts
typedef class Edge{
    public:
        int end;
        int next;
        int w;
        int id;
        Edge(const int end = 0, const int next = 0, const int w = 0, const int id = 0):end(end), next(next), w(w), id(id){}
}Edge;

typedef class MapManager{
    public:
        int ce;
        int *h;
        Edge *edge;
        MapManager(){}
        MapManager(int points, int limit):ce(0){
            h = new int[(const int)(points + 1)];
            edge = new Edge[(const int)(limit + 1)];
            memset(h, 0, sizeof(int) * (points + 1));
        }
        inline void addEdge(int from, int end, int w, int id){
            edge[++ce] = Edge(end, h[from], w, id);
            h[from] = ce;
        }
        inline void addDoubleEdge(int from, int end, int w, int id){
            addEdge(from, end, w, id);
            addEdge(end, from, w, id);
        }
        inline void clean(){
            delete[] h;
            delete[] edge;
            ce = 0;
        }
}MapManager;

#define m_begin(g, i) (g).h[(i)]
#define m_end(g, i) (g).edge[(i)].end
#define m_next(g, i) (g).edge[(i)].next
#define m_w(g, i) (g).edge[(i)].w
///map template ends

typedef class Fraction{
    public:
        int s;
        int m;
        Fraction():s(0),m(0){}
        Fraction(int s,int m){
            int g = getCommon(s, m);
            this->s = s / g;
            this->m = m / g;
        }
        boolean empty(){
            return m == 0;
        }
        boolean operator <(Fraction another) const{
            if(another.empty())    return true;
            if(m == 0)    return false;
            if(this->s == another.s) return this->m>another.m;
            return (this->s * 1.0 / this->m) < (another.s * 1.0 / another.m);
        }
    private:
        int getCommon(int a, int b){
            if(b == 0) return a;
            return getCommon(b, a % b);
        }
}Fraction;

typedef class Edge1{
    public:
        int end;
        int from;
        int w;
        Edge1(const int end = 0, const int from = 0, const int w = 0):end(end), from(from), w(w){}
}Edge1;

int n, m;
Edge1* edge;
union_found uf;
MapManager g;
int s, t;

inline boolean cmpare(const Edge1& a, const Edge1& b){
    return a.w > b.w;
}

inline void init(){
    readInteger(n);
    readInteger(m);
    edge = new Edge1[(const int)(m + 1)];
    for(int i = 1; i <= m; i++){
        readInteger(edge[i].from);
        readInteger(edge[i].end);
        readInteger(edge[i].w);
    }
    readInteger(s);
    readInteger(t);
}

int minl, maxl, maxide;
void dfs(int minv, int maxv, int maxid, int last, int node){
    if(node == t){
        minl = minv, maxl = maxv, maxide = maxid;
        return;
    }
    for(int i = m_begin(g, node); i != 0; i = m_next(g, i)){
        int& e = m_end(g, i);
        if(e == last)    continue;
        int nmin = min(minv, m_w(g, i));
        int nmax = max(maxv, m_w(g, i));
        int nid = (nmax == m_w(g, i)) ? (g.edge[i].id) : (maxid);
        dfs(nmin, nmax, nid, node, e);
    }
}

boolean *enable;
Fraction result;
inline void solve(){
    sort(edge + 1, edge + m + 1, cmpare);
    enable = new boolean[(const int)(m + 1)];
    memset(enable, true, sizeof(boolean) * (m + 1));
    uf = union_found(n);
    for(int i = 1; i <= m; i++){
        int j;
        g = MapManager(n, m * 2);
        for(j = 1; j <= m; j++){
            if(enable[j] && !uf.connected(edge[j].from, edge[j].end)){
                uf.unit(edge[j].from, edge[j].end);
                g.addDoubleEdge(edge[j].from, edge[j].end, edge[j].w, j);
                if(uf.connected(s, t)){
                    maxide = -1;
                    dfs(0x7fffffff, -1, -1, 0, s);
                    uf.clean();
                    g.clean();
                    break;
                }
            }
        }
        if(j == m + 1)    break;
        else{
            smin(result, Fraction(maxl, minl));
            enable[maxide] = false;
        }
    }
    if(result.empty())    printf("IMPOSSIBLE");
    else if(result.m != 1)    printf("%d/%d", result.s, result.m);
    else printf("%d", result.s);
}

int main(){
    init();
    solve();
    return 0;
}

---

后话

 　　最后加的那一条边是最小的限速，可以倒推，得到一条边使s, t连通，后者是最大的限速。还有个方法优化，把没有的边去掉，而不是一次一次地删最大的那条边，详见[传送门]