POJ 3255

求最短路径可以用Bellman、Dijkstra等算法，而且可以利用二叉堆来降低复杂度，但是求次短路径就比较难了。

参考《挑战程序设计竞赛》第二版，代码如下。

思路：按照Dijkstra算法求出最短路径，并在此基础上修改，保存次短路径长度。

关键点：每次从优先队列中取出的，要么是第一个if中dist[ ]加进去的最短路径长度，要么是第二个if中dist2[ ]中加进去的次短路径长度。需要注意的是，起始点到v的最短路径，要么是起始点到其它某个顶点u的最短路径加上u->v的边，要么是u的次短路径再加上u->v的边，所以第二个if语句恰好能得到次短路径长度。虽然不是起始点到每一个顶点的次短路径，但到最终点的次短路径长度是可以得到的。

注意：

（1）这种问题最好还是从逻辑的角度进行分析，要是总是跟着代码的思路走，遇到稍微复杂的问题就难以分析出来，也很难真正理解其含义。

（2）每次要把同一条边以两个顶点为目标顶点分别加到二叉堆中，为了防止顺着走下来不可能找到次长路径的情况。比如从路口1到路口5都是依次连接的，这时必须要出现一个环，即回去一下再过来。

（3）要到输入多种情况，尽管题目中没有明说，但如果没有设置输入多种情况则会报错，故有while(cin >> N >> R)。

#include<iostream>
#include<queue>
#include<algorithm>
#include<vector>

#define MAX_N 100010
#define INF 6000
using namespace std;

struct edge
{
	int to, cost;
};

typedef pair<int,int> P;  //first是最短距离，second是顶点编号

int main()
{
	int N, R;
	vector<edge> G[MAX_N];
	int dist[MAX_N];
	int dist2[MAX_N];
	priority_queue<P, vector<P>, greater<P> > que;

	while(cin >> N >> R)
	{
		for(int i = 0; i < R; i++)
		{
			int ii;
			cin >> ii;
			edge edge_ii;
			cin >> edge_ii.to >> edge_ii.cost;
			edge_ii.to -= 1;
			ii -= 1;
			G[ii].push_back(edge_ii);
			swap(edge_ii.to, ii);
			G[ii].push_back(edge_ii);
		}
		fill(dist, dist + N, INF);
		fill(dist2, dist2 + N, INF);
		dist[0] = 0;
		que.push(P(0, 0));

		while(!que.empty())
		{
			P p = que.top();
			que.pop();
			int v = p.second, d = p.first;
			if(dist2[v] < d) 
				continue;
			for(unsigned int i = 0; i < G[v].size(); i++)
			{
				edge &e = G[v][i];
				int d2 = d + e.cost;
				if(dist[e.to] > d2)
				{
					swap(dist[e.to], d2);
					que.push(P(dist[e.to], e.to));
				}
				if(dist2[e.to] > d2 && dist[e.to] < d2)
				{
					dist2[e.to] = d2;
					que.push(P(dist2[e.to], e.to));
				}
			}
		}
		cout << dist2[N-1];
	}
	return 0;
}