UVA - 10816 Travel in Desert(枚举＋生成树+最短路)

题目大意：给出N个点，M条边，每条边有相应的长度和温度。
现在给出起点和终点，问从起点到终点的路径中，温度最高的最小值是多少，路径路径长度是多少，经过了哪些点

解题思路：这题有两种解法

第一种：二分最高温度，然后跑最短路
第二种:按照kruscal算法来，按温度升序排序，当起点和终点连通的时候，那个时候的温度就是这条路的最高温度了
接着将所有低于等于该温度的边连成一张图，然后跑最短路即可

第一种思路:

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
using namespace std;

#define N 110
#define M 20010
#define esp 1e-6
#define INF 0x3f3f3f3f

struct Edge{
    int v, next;
    int t, d;
}E[M];

int head[N];
int n, m, tot, source, sink; 
int Max, Min;

void AddEdge(int u, int v, int t, int d) {
    E[tot].v = v; E[tot].t = t; E[tot].d = d; E[tot].next = head[u]; head[u] = tot++;
    u = u ^ v; v = u ^ v; u = u ^ v;
    E[tot].v = v; E[tot].t = t; E[tot].d = d; E[tot].next = head[u]; head[u] = tot++;
}

void init() {
    scanf("%d%d", &source, &sink);
    Max = 0; Min = INF;
    memset(head, -1, sizeof(head));
    tot = 0;
    int u, v, tt, dd;
    double t, d;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%lf%lf", &u, &v, &t, &d);
        tt = (int)(round(t * 10.0));
        dd = (int)(round(d * 10.0));
        Max = max(Max, tt);
        Min = min(Min, tt);
        AddEdge(u, v, tt, dd);
    }
}

struct Node{
    int u, d;
    Node() {}
    Node(int u, int d): u(u), d(d) {}
    bool operator < (const Node &a) const {
        return d > a.d;
    }
};

int pre[N];
int d[N];
bool vis[N];
bool dijkstra(int mid) {
    memset(vis, 0, sizeof(vis));
    memset(pre, 0,sizeof(pre));
    pre[source] = -1;
    priority_queue<Node> Q;
    for (int i = 1; i <= n; i++)  
        d[i] = INF;
    d[source] = 0;
    Q.push(Node(source, 0));
    while (!Q.empty()) {
        Node t = Q.top();
        Q.pop();
        if (vis[t.u]) continue;
        vis[t.u] = true;
        for (int i = head[t.u]; ~i; i = E[i].next) {
            int v = E[i].v;
            if (d[v] > d[t.u] + E[i].d && E[i].t <= mid) {
                d[v] = d[t.u] + E[i].d;
                pre[v] = t.u;
                Q.push(Node(v, d[v]));
            }
        }
    }
    return d[sink] != INF;
}

void out(int v) {
    if (pre[v] < 0) {
        printf("%d", v);
        return ;
    }
    out(pre[v]);
    printf(" %d", v);
}
void solve() {
    int l = Min, r = Max, mid;
    while (r > l) {
        double mid = (l + r) / 2;
        if (dijkstra(mid)) r = mid;
        else l = mid +  1;
    }
    dijkstra(r);
    out(sink);
    printf("\n");
    printf("%.1lf %.1lf\n", d[sink] / 10.0, r / 10.0);
}

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        init();
        solve();
    }
    return 0;
}

第二种思路：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;

#define N 110
#define M 10010
#define INF 0x3f3f3f3f

struct Edge{
    int u, v, t, d;
    Edge() {}
    Edge(int u, int v, int t, int d): u(u), v(v), t(t), d(d) {}
}edge[M];

struct Edge2{
    int v, d, next;
}E[2*M];

int n, m, s, t, tot, ans_tmp;
int f[N], head[N], d[N], pre[N];
bool vis[N];

int cmp(const Edge &a, const Edge &b) {
    if (a.t == b.t)
        return a.d < b.d;
    return a.t < b.t;
}

void AddEdge(int u, int v, int d) {
    E[tot].v = v; E[tot].d = d; E[tot].next = head[u]; head[u] = tot++;
    u = u ^ v; v = u ^ v; u = u ^ v;
    E[tot].v = v; E[tot].d = d; E[tot].next = head[u]; head[u] = tot++;
}

int find(int x) {
    return x == f[x] ? x : f[x] = find(f[x]);   
}

void kruscal() {
    for (int i = 1; i <= n; i++)
        f[i] = i;
    sort(edge, edge + m, cmp);
    int xx, yy;
    ans_tmp = INF;
    for (int i = 0; i < m; i++) {
        if (edge[i].t > ans_tmp) break;
        xx = find(edge[i].u);
        yy = find(edge[i].v);
        AddEdge(edge[i].u, edge[i].v, edge[i].d);

        if (xx != yy) {
            f[xx] = yy;
            if (find(s) == find(t)) ans_tmp = edge[i].t;
        }
    }
}

void spfa() {
    for (int i = 1; i <= n; i++)
        d[i] = INF;
    memset(pre, -1, sizeof(pre));
    memset(vis, 0, sizeof(vis));
    d[s] = 0;
    queue<int> Q;
    Q.push(s);

    while (!Q.empty()) {
        int u = Q.front();
        Q.pop();

        for (int i = head[u]; ~i; i = E[i].next) {
            int v = E[i].v;
            if (d[v] > d[u] + E[i].d) {
                d[v] = d[u] + E[i].d;
                pre[v] = u;
                if (!vis[v]) {
                    vis[v] = true;
                    Q.push(v);
                }
            }
        }
        vis[u] = false;
    }
}

void print(int u) {
    if (pre[u] == -1) {
        printf("%d", u);
        return ;
    }
    print(pre[u]);
    printf(" %d", u);
}

void solve() {
    memset(head, -1, sizeof(head));
    tot = 0;
    kruscal();
    spfa();
    print(t);
    printf("\n");
    printf("%.1lf %.1lf\n", d[t] / 10.0, ans_tmp / 10.0);
}

void init() {
    scanf("%d%d", &s, &t);
    int u, v, tt, dd;
    double t, d;

    for (int i = 0; i < m; i++) {
        scanf("%d%d%lf%lf", &u, &v, &t, &d);
        tt = (int)(round(t * 10.0));
        dd = (int)(round(d * 10.0));
        edge[i] = Edge(u, v, tt, dd);   
    }
}

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        init();
        solve();
    }
    return 0;
}