Codevs 1021 玛丽卡==洛谷 P1186

时间限制: 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<iostream>
 #include<cstdio>
 #include<cstring>
 #include<queue>
 using namespace std;
 int map[][],pre[],dis[],lu[];
 int n,m,tot,ans=;
 bool exist[];
 void SPFA(int s)
 {
     queue<int> q;
     memset(dis,0x3f,sizeof(dis));
     memset(exist,false,sizeof(exist));
     dis[]=;exist[s]=true;q.push(s);
     while(!q.empty()){
         int x=q.front();q.pop();
         exist[x]=false;
         for(int i=;i<=n;i++)
         {
             if(dis[i]>dis[x]+map[x][i]){
                 dis[i]=dis[x]+map[x][i];pre[i]=x;
                 if(exist[i]==false){
                     q.push(i);exist[i]=true;
                 }
             }
         }
     }
 }
 void dij()
 {
     int minl,k;
     memset(dis,0x3f,sizeof(dis));
     memset(exist,false,sizeof(exist));
     dis[]=;
     for(int i=;i<=n;i++)
     {
         minl=0x5f;
         for(int j=;j<=n;j++)
           if(exist[j]==false&&dis[j]<minl)
             k=j,minl=dis[j];
         exist[k]=true;
         for(int j=;j<=n;j++)
           if(map[k][j]!=&&dis[j]>dis[k]+map[k][j])
             dis[j]=dis[k]+map[k][j];
     }
 }
 int main()
 {
     scanf("%d%d",&n,&m);
     for(int i=,x,y,z;i<=m;i++){
         scanf("%d%d%d",&x,&y,&z);
         map[x][y]=map[y][x]=z;
     }
     pre[]=;
     SPFA();
     ans=max(ans,dis[n]);
     ++tot;lu[tot]=n;
     int p=n;
     while(pre[p]!=){
         ++tot;
         lu[tot]=pre[p];
         p=pre[p];
     }
     for(int i=;i<=tot-;i++){
         int k=map[lu[i]][lu[i+]];
         map[lu[i]][lu[i+]]=;
         map[lu[i+]][lu[i]]=;
         dij();
         ans=max(ans,dis[n]);
         map[lu[i]][lu[i+]]=k;
         map[lu[i+]][lu[i]]=k;
     }
     printf("%d",ans);
     return ;
 }

以上是我的代码 本人认为没毛病，求大神解救~~

AC代码：

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<queue>
 using namespace std;
 const int maxn = ;
 const int maxm = maxn*(maxn - )/;
 struct Edge
 {
     int u,v,w,next;
 } edge[maxm];
 int head[maxm],vis[maxn],dis[maxn],prev[maxn];
 int N,M,tot = ,res;

 void addedge(int u,int v,int w)
 {
     edge[tot] = (Edge)
     {
         u,v,w,head[u]
     };
     head[u] = tot++;
 }

 int spfa(int x,int y)   //虽然玛丽卡在第N个城市，但是1-N的最短距离固定，
 {                       // 所以我们可以从第1个城市出发，求出1-N的最短路
     memset(dis,0x3f,sizeof(dis));
     memset(vis,,sizeof(vis));
     queue<int>que;
     dis[] = ;
     que.push();
     vis[] = ;
     while (!que.empty())
     {
         int u = que.front();
         que.pop();
         vis[u] = ;
         for (int i = head[u]; i != -; i = edge[i].next)
         {
             int v = edge[i].v;
             if ((u == x && v == y) || (u == y && v == x))   continue;
             if (dis[u] + edge[i].w < dis[v])
             {
                 dis[v] = dis[u] + edge[i].w;
                 prev[v] = u;           //记录前驱（路径）
                 if (!vis[v])
                 {
                     que.push(v);
                     vis[v] = ;
                 }
             }
         }
     }
     return dis[N];
 }

 int main()
 {

     int u,v,w;
     memset(head,-,sizeof(head));
     memset(prev,,sizeof(prev));
     scanf("%d%d",&N,&M);
     for (int i = ; i < M; i++)
     {
         scanf("%d%d%d",&u,&v,&w);
         addedge(u,v,w);
         addedge(v,u,w);
     }
     res = spfa(,);
     int tmp = N;
     queue<int>q;
     while (tmp)
     {
         q.push(tmp);
         tmp = prev[tmp];
     }
     while (q.size() > )
     {
         tmp = q.front();
         q.pop();
         res = max(res,spfa(tmp,q.front()));
     }
     printf("%d\n",res);
     return ;
 }

我们可以用一遍SPFA，求出最短路，然后不难发现，炸最短路上的边可以是答案变得更大，而炸掉非最短路上的边对答案没任何影响