P2865 【[USACO06NOV]路障Roadblocks】（次短路）

传送门

算法
Dijkstra
要求次短路

那么在不考虑重复走一条边的情况下

肯定是把最短路中的一段改成另一段

至少要换另一条边到路径里
所以可以枚举所有不属于最短路的每条边（a,b）

那么dis（1,a）+（a,b）+ dis(b,n)就是一种可能的答案（记为S）

显然如果另一条不属于S的边更新S后会使S更长，就不可能为次短路了

那么只要对起点1和终点n分别跑Dijkstra就可以求出每个dis(1,a)和dis(b,n)

至于判断一条边是否在最短路上也很容易：

显然，如果dis(1,a)+(a,b)=dis(1,b)，那么边(a,b)就在最短路径上

然后考虑重复走一条边情况（显然也只要考虑重复走一条边的情况）

也很简单，用贪心的思想

找到最短路径上最短的边(a,b)，如果重复走一条边的情况为次短路，那么肯定是dis(1,n)+(a,b)*2 （走过去又走回来，要乘2）

如果（c,d）不是最短的边，那么dis(1,n)+(c,d)*2肯定大于dis(1,n)+(a,b)*2，就不可能是次短路

然后就可以了，实现时要注意一下细节

 

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
inline int read()
{
    int res=0;
    char ch=getchar();
    while(ch>'9'||ch<'0')
        ch=getchar();
    while(ch>='0'&&ch<='9')
    {
        res=res*10+ch-'0';
        ch=getchar();
    }
    return res;
}
struct node//存Dijkstra的优先队列中的数据
{
    int u,v;//v为点的编号，u表示从起点到v的距离
    bool operator < (const node &b) const{
        return u>b.u;
    }
};
priority_queue <node> q;//为Dijkstra开的优先队列
struct edge
{
    int from,to,z;
}e[1000007];
int fir[50007],cnt;//链式前向星存图
inline void add(int a,int b,int c)
{
    e[++cnt].from=fir[a];
    fir[a]=cnt;
    e[cnt].to=b;
    e[cnt].z=c;
}//加边
int n,m,ans=199999999;
int dis[50007][2];
//dis[][0]为起点到各个点的距离，dis[][1]为终点到各个点的距离
inline void dijk(int sta,int k)
//sta为开始点，k为dis的第二维
{
    dis[sta][k]=0;
    node p;
    p.u=0; p.v=sta;
    q.push(p);
    while(q.empty()==0)
    {
        int u=q.top().u,v=q.top().v;
        q.pop();
        if(u!=dis[v][k]) continue; //优化
        for(int i=fir[v];i;i=e[i].from)
        {
            int to=e[i].to;
            if(dis[to][k]>dis[v][k]+e[i].z)
            {
                dis[to][k]=dis[v][k]+e[i].z;
                p.u=dis[to][k]; p.v=to;
                q.push(p);
            }
        }
    }
}//Dijkstra的模板
struct data
{
    int x,y,z;
}d[1000007];//存读入的数据
int main()
{
    memset(dis,0x7f,sizeof(dis));
    int a,b,c,mi=199999999;//mi表示最短路径上最短的边长
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        a=read(); b=read(); c=read();
        d[i].x=a; d[i].y=b; d[i].z=c;
        add(a,b,c); add(b,a,c);
    }//读入
    dijk(1,0); dijk(n,1);//跑最短路
    int mx=dis[n][0];
    for(int i=1;i<=m;i++)
    //考虑不重复走一条边的情况
    {
        int x=d[i].x,y=d[i].y;
        if(dis[x][0]+dis[y][1]>dis[y][0]+dis[x][1]) swap(x,y);
        //重要的细节,1到x的路径不能和y到n的路径重复
        int s=dis[x][0]+dis[y][1];
        if(s+d[i].z==mx) continue;//判断边(x,y)是否在最短路径上,如果在就不能选
        ans=min(ans,s+d[i].z);//否则就尝试更新答案
    }
    for(int i=1;i<=m;i++)
    //考虑重复走一条边的情况，显然只要考虑在最短路径上的边
    {
        int x=d[i].x,y=d[i].y;
        if(dis[x][0]+dis[y][1]>dis[y][0]+dis[x][1]) swap(x,y);
        //同样，1到x的路径不能和y到n的路径重复
        if(dis[x][0]+dis[y][1]+d[i].z!=mx) continue;//如果边(x,y)不在最短路径上就不能考虑
        mi=min(mi,d[i].z);//尝试更新mi
    }
    ans=min(ans,mx+mi*2);//答案取较小值
    cout<<ans;
    return 0;
}

 

转载于:https://www.cnblogs.com/LLTYYC/p/9615256.html