3255 Roadblocks

#题目

Roadblocks

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 19318		Accepted: 6779

Description

Bessie has moved to a small farm and sometimes enjoys returning to visit one of her best friends. She does not want to get to her old home too quickly, because she likes the scenery along the way. She has decided to take the second-shortest rather than the shortest path. She knows there must be some second-shortest path.

The countryside consists of R (1 ≤ R ≤ 100,000) bidirectional roads, each linking two of the N (1 ≤ N ≤ 5000) intersections, conveniently numbered 1..N. Bessie starts at intersection 1, and her friend (the destination) is at intersection N.

The second-shortest path may share roads with any of the shortest paths, and it may backtrack i.e., use the same road or intersection more than once. The second-shortest path is the shortest path whose length is longer than the shortest path(s) (i.e., if two or more shortest paths exist, the second-shortest path is the one whose length is longer than those but no longer than any other path).

Input

Line 1: Two space-separated integers: N and R 
Lines 2..R+1: Each line contains three space-separated integers: A, B, and D that describe a road that connects intersections A and B and has length D (1 ≤ D ≤ 5000)

Output

Line 1: The length of the second shortest path between node 1 and node N

Sample Input

4 4
1 2 100
2 4 200
2 3 250
3 4 100

Sample Output

450

Hint

Two routes: 1 -> 2 -> 4 (length 100+200=300) and 1 -> 2 -> 3 -> 4 (length 100+250+100=450)

#分析

即求图内编号为V的点到起始点的次短距离

顶点的抛弃条件从比最短距离长变为比次短距离长。

只要比次短距离短，就有可能为次短或者最短，进一步判断后，对其相邻点进行更新。

这里秉承一个逻辑，最短距离由接邻点最短距离更新得到，次短距离由接邻点次短距离更新得到，所以que队列中对所有次短和最短距离进行保存，然后对其相邻点更新。

使用优先队列来记录接下来需要更新的顶点，是为了减少查找时间，否则当边数不多时，大部分时间会用于查找下一个顶点。

#AC码

#include<iostream>
#include<string.h>
#include<vector>
#include<queue>
using namespace std;
#define INF 0x3f3f3f3f
#define Max_N 5005
struct edge{int to,cost;};
typedef pair<int,int> P;  //first为到S最短距离，second为顶点编号

int V,E;
vector<edge> G[Max_N];  //每个G[v]里面包含一个边的edge类型vector，记录与顶点v相连的点和他们组成边的权值
int d[Max_N];  //记录S到此顶点的最短距离
int d2[Max_N]; //记录S到此顶点的次短距离

void dijkstra(int S)
{
    //创造优先队列que
    priority_queue<P,vector<P>,greater<P> > que;  //que里面会存储到顶点的次短距离和最短距离
    fill(d,d+V+1,INF);
    fill(d2,d2+V+1,INF);
    d[S]=0;
    que.push(P(0,S));

    while(!que.empty())
    {
        P p=que.top();
        que.pop();
        int v=p.second;
        if(d2[v]<p.first) continue;  //比次短距离长，跳过
        for(int i=0;i<G[v].size();i++)
        {
            edge &e=G[v][i];
            int di2=p.first+e.cost;  //此次更新后e.to这个点可取的值
            if(d[e.to]>di2)   //此次更新的di2比最短距离还小
            {
                swap(d[e.to],di2);
                que.push(P(d[e.to],e.to));
            }
            if(d2[e.to]>di2&&d[e.to]<di2)  //如果di2是新的次短距离
            {
                d2[e.to]=di2;
                que.push(P(d2[e.to],e.to));
            }
        }
    }
}
int main()
{
    //freopen("3255.txt","r",stdin);
    cin>>V>>E;
    for(int i=0;i<E;i++)
    {
        int s,t,co;  //s为起点，t为终点，co为权
        cin>>s>>t>>co;
        G[s].push_back({t,co});
        G[t].push_back({s,co});
    }
    //
    dijkstra(1);
    cout<<d2[V]<<endl;

}