Codevs_P1021 玛丽卡(Dijkstra)

时间限制: 2 s
空间限制: 128000 KB
题目等级 : 大师 Master

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

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

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

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

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

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

输入描述 Input Description
第一行有两个用空格隔开的数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 Description
输出文件的第一行中写出用分钟表示的最长时间，在这段时间中，无论哪条路在堵车，玛丽卡应该能够到达麦克处，如果少于这个时间的话，则必定存在一条路，该条路一旦堵车，玛丽卡就不能够赶到麦克处。

样例输入 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

#include<cstdio>
#include<cstring>
#include<climits>
#include<map>
#include<queue>
#include<vector>
#include<iostream>
using namespace std;
#define N 1050
struct Edge{
    int fr,to,vv;
    Edge(int f,int t,int v):fr(f),to(t),vv(v){}
};
struct HeapNode{
    int d,t;
    bool operator<(const HeapNode& rhs) const{
        return d>rhs.d;
    }
};
struct Dijkstra{
    int n,m,l,tt,ta,tb;
    vector<Edge> edge;
    vector<int> g[N];
    bool b[N];
    int d[N],p[N];
    map<int,bool> ha;

    void Add_Edge(int fr,int to,int v){
        edge.push_back(Edge(fr,to,v));
        m=edge.size();
        g[fr].push_back(m-1);
    }

    int dijkstra(int s,int t,bool y){
        priority_queue<HeapNode> q;
        for(int i=1;i<=n;i++) d[i]=99999999,b[i]=false;
        d[s]=0;
        q.push((HeapNode){0,s});
        while(!q.empty()){
            int x=q.top().t;q.pop();
            if(b[x]) continue;
            b[x]=true;
            for(int i=0;i<g[x].size();i++){
                Edge& e=edge[g[x][i]];
                if(d[e.to]>d[x]+e.vv){
                    d[e.to]=d[x]+e.vv;
                    if(y&&!ha[g[x][i]]&&!ha[g[x][i]^1]) p[e.to]=g[x][i];
                }
                q.push((HeapNode){d[e.to],e.to});
            }
        }
        return d[t];
    }

    int find_max(){
        dijkstra(1,n,true);int i=n;
        while(i!=1){
            ta=edge[p[i]^1].vv,tb=edge[p[i]].vv;
            edge[p[i]^1].vv=99999999,edge[p[i]].vv=99999999;
            l=max(dijkstra(1,n,false),l);
            edge[p[i]^1].vv=ta,edge[p[i]].vv=tb;
            i=edge[p[i]].fr;
        }
        return l;
    }
}a;

int in(){
    int x=0;char ch=getchar();
    while(ch>'9'||ch<'0') ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x;
}
int main(){
    int n,m,fr,to,vv;
    n=in(),m=in();
    a.n=n;
    for(int i=1;i<=m;i++){
        fr=in(),to=in(),vv=in();
        a.Add_Edge(fr,to,vv);
        a.Add_Edge(to,fr,vv);
    }

    printf("%d",a.find_max());
    return 0;
}