POJ 1797-Heavy Transportation(Dijkstra + 二分答案）

题目链接：http://poj.org/problem?id=1797

题意

每条路径都有一个最大负重值，求一条从起点到终点的路径使最小负重值最大

思路

对负重值进行二分，在Dijsktra的时候判断一下即可

代码

#include <iostream>
#include <cstring>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <sstream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <climits>
#include <deque>
#include <bitset>
#include <algorithm>
using namespace std;

#define PI acos(-1.0)
#define LL long long
#define PII pair<int, int>
#define PLL pair<LL, LL>
#define mp make_pair
#define IN freopen("in.txt", "r", stdin)
#define OUT freopen("out.txt", "wb", stdout)
#define scan(x) scanf("%d", &x)
#define scan2(x, y) scanf("%d%d", &x, &y)
#define scan3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define sqr(x) (x) * (x)
#define pr(x) cout << #x << " = " << x << endl
#define lc o << 1
#define rc o << 1 | 1
#define pl() cout << endl
#define INF 0x3f3f3f3f

const int maxn = 1005;
int M;

struct Edge {
    int from, to, dist;
    Edge(int u, int v, int w) : from(u), to(v), dist(w) {

    }
};

struct Heapnode {
    int d, u;
    bool operator < (const Heapnode& node2) const {
        return d > node2.d;
    }
};

struct Dijkstra {
    int n, m;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool vis[maxn];
    int d[maxn], p[maxn];

    void init(int n) {
        this->n = n;
        for (int i = 0; i < n; i++) G[i].clear();
        edges.clear();
    }

    void addedge(int u, int v, int w) {
        edges.push_back(Edge(u, v, w));
        int m = edges.size();
        G[u].push_back(m - 1);
    }

    bool dijkstra(int s) {
        priority_queue<Heapnode> q;
        for (int i = 1; i <= n; i++) d[i] = INF;
        d[s] = 0;
        memset(vis, 0, sizeof(vis));
        q.push((Heapnode){0, s});
        while (!q.empty()) {
            Heapnode t = q.top();
            q.pop();
            int u = t.u;
            if (vis[u]) continue;
            vis[u] = true;
            int _s = G[u].size();
            for (int i = 0; i < _s; i++) {
                Edge &e = edges[G[u][i]];
                //只需要在这里判断一下e.dist >= M即可
                if (d[e.to] > d[u] + e.dist && e.dist >= M) {
                    d[e.to] = d[u] + e.dist;
                    p[e.to] = G[u][i];
                    q.push((Heapnode){d[e.to], e.to});
                }
            }
        }
        return d[n] != INF;
    }
};


int main() {
    int T, n, m;
    int x, y, z;
    scan(T);
    for (int t = 1; t <= T; t++) {
        int L = 0, R = 0;
        scan2(n, m);
        Dijkstra D;
        D.init(n);
        while (m--) {
            scan3(x, y, z);
            R = max(R, z);
            D.addedge(x, y, z);
            D.addedge(y, x, z);
        }
        while (L < R) {
            if (R == L + 1) {
                M = R;
                if (D.dijkstra(1)) M = R;
                else M = L;
                break;
            }
            M = (L + R) >> 1;
            if (D.dijkstra(1)) L = M;
            else R = M;
        }
        printf("Scenario #%d:\n", t);
        printf("%d\n\n", M);
    }
    return 0;
}