luogu 1186 玛丽卡

Description

    麦克找了个新女朋友，玛丽卡对他非常恼火并伺机报复。

    因为她和他们不住在同一个城市，因此她开始准备她的长途旅行。

    在这个国家中每两个城市之间最多只有一条路相通，并且我们知道从一个城市到另一个城市路上所需花费的时间。

    麦克在车中无意中听到有一条路正在维修，并且那儿正堵车，但没听清楚到底是哪一条路。无论哪一条路正在维修，从玛丽卡所在的城市都能到达麦克所在的城市。

    玛丽卡将只从不堵车的路上通过，并且她将按最短路线行车。麦克希望知道在最糟糕的情况下玛丽卡到达他所在的城市需要多长时间，这样他就能保证他的女朋友离开该城市足够远。

    编写程序，帮助麦克找出玛丽卡按最短路线通过不堵车道路到达他所在城市所需的最长时间(用分钟表示)。

Input

    第一行有两个用空格隔开的数N和M，分别表示城市的数量以及城市间道路的数量。1≤N≤1000，1≤M≤N*(N-1)/2。城市用数字1至N标识，麦克在城市1中，玛丽卡在城市N中。

    接下来的M行中每行包含三个用空格隔开的数A，B和V。其中1≤A，B≤N，1≤V≤1000。这些数字表示在A和城市B中间有一条双行道，并且在V分钟内是就能通过。

Output

    输出文件的第一行中写出用分钟表示的最长时间，在这段时间中，无论哪条路在堵车，玛丽卡应该能够到达麦克处，如果少于这个时间的话，则必定存在一条路，该条路一旦堵车，玛丽卡就不能够赶到麦克处。

Sample input

5 7
1 2 8
1 4 10
2 3 9
2 4 10
2 5 1
3 4 7
3 5 10

Sample Output

27

Hint

     $1≤N≤1000,\ 1≤M≤N*(N-1)/2,\ 1≤A，B≤N，1≤V≤1000$

---

Solution :

    题目中给出了 $N \le 1000$， 那我们就可以先跑一遍最短路，求出当前最短路径，将当前的最短路径提出，然后在最短路上枚举删边，由于你从 1 到 n 最多经过 n - 1 条边，所以我们的复杂的是 $O(n * n * log_2n)$ 其中 $n * log_2n$ 的复杂度是源于 Dijkstra，这道题是可以用 SPFA 的，题目中并没有卡，其实本来就是个稀疏图，SPFA 跑的还挺快的。

Code:

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <ctime>
#include <map>
#include <vector>
#include <queue>
#define mp make_pair
using namespace std;

inline int read() {
    int i = 0, f = 1;
    char ch = getchar();
    while(!isdigit(ch)) {
        if(ch == '-') f = -1; ch = getchar();
    }
    while(isdigit(ch)) {
        i = (i << 3) + (i << 1) + ch - '0'; ch = getchar();
    }
    return i * f;
}

const int MAXN = 1000 + 5;
int first[MAXN], dis[MAXN], to[MAXN * MAXN], nxt[MAXN * MAXN], len[MAXN * MAXN];
int tot, n, m, pre[MAXN];
priority_queue<pair<int, int> > q;

inline void addedge(int x, int y, int w) {
    nxt[++tot] = first[x]; first[x] = tot; to[tot] = y; len[tot] = w;
    nxt[++tot] = first[y]; first[y] = tot; to[tot] = x; len[tot] = w;
}

inline void dij() {
    memset(dis, 0x3f, sizeof(dis));
    dis[1] = 0; q.push(mp(0, 1));
    while(!q.empty()) {
        pair<int, int> u = q.top(); q.pop();
        for(int i = first[u.second]; i; i = nxt[i]) 
            if(dis[to[i]] > dis[u.second] + len[i]) {
                dis[to[i]] = dis[u.second] + len[i];
                pre[to[i]] = i ^ 1;
                q.push(mp(-dis[to[i]], to[i]));    
            }
    }
}

inline int solve() {
    memset(dis, 0x3f, sizeof(dis));
    while(!q.empty()) q.pop();
    dis[1] = 0, q.push(mp(0, 1));
    while(!q.empty()) {
        pair<int, int> u = q.top(); q.pop();
        if(u.second == n) return dis[n];
        for(int i = first[u.second]; i; i = nxt[i]) 
            if(dis[to[i]] > dis[u.second] + len[i]) {
                dis[to[i]] = dis[u.second] + len[i];
                q.push(mp(-dis[to[i]], to[i]));
            }
    }
    return dis[n];
}

int main() {
    n = read(), m = read();
    tot = 1;
    for(int i = 1; i <= m; ++i) {
        int x = read(), y = read(), w = read();
        addedge(x, y, w);
    }
    dij();
    int ans = 0;
    for(int i = pre[n] ;; i = pre[to[i]]) {
        int now = len[i]; 
        len[i] = 0x3f3f3f3f;
        len[i ^ 1] = 0x3f3f3f3f;
        ans = max(ans, solve());
        len[i] = now;
        len[i ^ 1] = now; 
        if(to[i] == 1) break;
    }
    printf("%d\n", ans);
}