P1186 玛丽卡

P1186 玛丽卡

题目描述

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

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

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

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

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

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

输入输出格式

输入格式：

第一行有两个用空格隔开的数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分钟内是就能通过。

输出格式：

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

输入输出样例

输入样例#1：

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

输出样例#1：

27

 

分析：

方法一：

spfa+spfa

先SPFA求出最短路，然后枚举去掉哪条边，再跑n次spfa，记录结果得出最大的方案。

这道题可以用图论求最短路解决，第一次跑最短路时记录最短路上的每条边（这里的边是无向的），然后再依次删除最短路上的每一条边（因为删除其他边最短路不变，所以只需删最短路上的便就行了），再跑SPFA。

注意！！！SPFA再这道题上会有一个点超时，这里介绍一种简单而又实用的优化方法

SLF优化：将某个点加入队列是，设当前点为 v，队首元素为u，若dist[v] < dist[u]，即把 v 加入到队列的头部，否则加入到队列尾部。

用双端队列deque实现。

优化思想就是：利用价值最大的点最先处理

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<deque>
#include<cstring>

using namespace std;

struct edge
{
    int v;
    int next;
    int w;
}e[1000050];

int ans,dist[1005],p[1005],head[1005],cnt,delu,delv;
bool vis[1005];

void add(int u,int v,int w)//添加边
{
    e[++cnt] = (edge){v,head[u],w};
    head[u] = cnt;
}

int read() //读入优化 
{
    int ans=0;char ch = getchar();
    while(ch<'0'||ch>'9')    ch = getchar();
    while(ch>='0'&&ch<='9') {ans = ans *10 + ch - '0';ch = getchar();}
    return ans;
}

void spfa()
{
    int v,u;
    deque<int> q;//双向队列
    memset(dist,-1,sizeof(dist));
    memset(vis,false,sizeof(vis));
    q.push_back(1);
    dist[1] = 0;
    vis[1] = true;
    while(!q.empty())
    {
        u = q.front();
        q.pop_front();
        for(int i=head[u];i;i=e[i].next)
        {
            v = e[i].v;
            if(dist[v]<0 || dist[v]>dist[u]+e[i].w)
            {
                if(!(u==delu&&v==delv)||(v==delu&&u==delv))//判断边是否被删除
                {
                    dist[v] = dist[u] + e[i].w;
                    if(!ans)//如果已经跑过一次最短路就不要记录边了
                        p[v] = u;
                    if(!vis[v])
                    {
                        if(!q.empty())
                        {
                            if(dist[v]<dist[q.front()])
                                q.push_front(v);
                            else
                                q.push_back(v);
                        }
                        else
                            q.push_back(v);
                        vis[v] = true;
                    }
                }
            }
        }
        vis[u] = false;
    }
}

int main()
{
    int n,m;
    n=read();
    m=read(); 
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        u=read();
        v=read();
        w=read();
        add(u,v,w);
        add(v,u,w);
    }
    spfa();
    ans = dist[n];
    for(int i = n;i!=1;i = p[i])
    {
        delu = p[i];//依次删除最短路上的边
        delv = i;
        spfa();
        ans = max(dist[n],ans);
    }
    printf("%d",ans);
    return 0;
}

方法二：

堆优化的dijkstra（用优先队列实现）

先dijkstra求出最短路，然后枚举去掉哪条边，再跑n次dijkstra，记录结果得出最大的方案。

 

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <iostream>
using namespace std;
const int maxn=1000+20,inf=1234567890;
typedef pair<int,int> P;
struct edge{int to,w;};
vector<edge>G[maxn];
int n,m,pre[maxn],d[maxn];
priority_queue<P,vector<P>,greater<P> >que;
void read(int &n){
    n=0;int f=1;
    char ch=getchar();
    while(ch<'0' || ch>'9'){
        if(ch=='-') f=-1;
        ch=getchar();
    }
    do{
        n=n*10+ch-'0';
        ch=getchar();
    }while(ch>='0' && ch<='9');
    n=n*f;
    return;
}
void write(int n){
    if(n<0){
        putchar('-');
        n=0-n;
    }
    if(n>=10) write(n/10);
    putchar((n % 10)+'0');
    return;
}
inline void add_edge(int u,int v,int w){
    edge e;e.to=v;e.w=w;
    G[u].push_back(e);
    return;
}
void init(){
    read(n);read(m);
    for(int i=1;i<=m;i++){
        int u,v,w;
        read(u);read(v);read(w);
        add_edge(u,v,w);
        add_edge(v,u,w);
    }
    return;
}
int dijkstra(int f,int ff){
    for(int i=1;i<=n;i++) d[i]=inf;
    d[1]=0;
    P p(0,1);que.push(p);
    while(!que.empty()){
        P temp=que.top();
        que.pop();
        int u=temp.second;
        if(d[u]<temp.first) continue;
        for(int i=0;i<G[u].size();i++){
            int v=G[u][i].to;
            if(f==u && ff==v) continue;
            if(ff==u && f==v) continue;
            int w=G[u][i].w;
            int t=d[u]+w;
            if(d[v]>t){
                d[v]=t;
                que.push(P(t,v));
                if(!f && !ff) pre[v]=u;
            }
        }
    }
    return d[n];
}
void solve(){
    memset(pre,-1,sizeof(pre));
    int ans=dijkstra(0,0);
    int u=n;
    while(pre[u]!=-1){
        int r=dijkstra(u,pre[u]);
        if(r!=inf) ans=max(ans,r);
        u=pre[u];
    }
    write(ans);
    return;
}
int main(){
    init();
    solve();
    return 0;
}