POJ 3255 图论基础 次短路

题目链接：http://poj.org/problem?id=3255
题意：
某街道共有R条道路、N个路口。道路可以双向通行。问1号路口到N号路口的次短路长度是多少？同一条边可以经过多次。
规模：
1<=N<=5000
1<=R<=100000

类型：
最短路变形

分析：
次短路[v]=最短路[u]+边[u,v] 或者 次短路[v]=次短路[u]+边[u,v]
不同于普通最短路，我们需要维护两个数组：最短路+次短路。
我这里采用 邻接表+dijkstra，不断更新最短路和次短路。

时间复杂度&&优化：
第一次使用的是邻接矩阵存储，但次短路里一些关键点没想通。
上网发现大神们都是用邻接表在做，而且这道题用邻接矩阵会超时。
进一步了解发现，邻接表储存会在空间和访问上优于邻接矩阵，果断抛弃掉矩阵，重新学习。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#define INF 0xfffffff
using namespace std;

struct Edge{
    int to,cost;
};
int n,r;
vector<Edge> edge[5005];
typedef pair<int,int> P;//first是最短距离，second是顶点编号
int dis1[5005];//最短距离
int dis2[5005];//次短距离

void solve(){
    priority_queue<P,vector<P>,greater<P> > q;//递增的优先队列
    for(int i = 0; i <= n; i++){
        dis1[i] = INF;
        dis2[i] = INF;
    }
    dis1[1] = 0;
    q.push(P(0,1));
    while(!q.empty()){
        P p = q.top();
        q.pop();
        int v = p.second,d = p.first;
        if(dis2[v] < d)
            continue;
        for(int i = 0; i < edge[v].size(); i++){
            Edge &e = edge[v][i];
            int d2 = d + e.cost;
            //最短距离的更新，入队
            if(dis1[e.to] > d2){
                swap(dis1[e.to],d2);
                q.push(P(dis1[e.to],e.to));
            }
            //新的次短距离 应该 小于最短距离&&大于原来的次短距离
            if(dis2[e.to] > d2 && dis1[e.to] < d2){
                dis2[e.to] = d2;
                q.push(P(dis2[e.to],e.to));//入队
            }
        }
    }
    printf("%d\n",dis2[n]);
}

int main(){
    while(~scanf("%d%d",&n,&r)){
        for(int i = 0; i <= n; i++)
            edge[i].clear();
        int u,v,cost;
        Edge tmp;
        for(int i = 0; i < r; i++){
            scanf("%d%d%d",&u,&v,&cost);
            tmp.to = v;tmp.cost = cost;
            edge[u].push_back(tmp);
            tmp.to = u;
            edge[v].push_back(tmp);
        }
        solve();
    }
    return 0;
}