Roadblocks(POJ 3255)

POJ 3255 Roadblocks

题目大意：

​ 某个街区有$R$ $(1\le R\le 100,000)$条道路，$N$ $(1\le N\le 5000)$个 路口，道路双向通行，求$1$号路口到$N$号路口的次短路径长度是多少？（同一条边可以经过多次）

输入

第一行$n$,$r$。接下来$r$行三个整数$A$,$B$,$D$ ，表示$A$与$B$相连，长度为$D$

输出

从$1$到$N$的次短路径

样例输入

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

样例输出

450

题目要求次短路径，次短路径只能由两种途径得到，例如要求到$v$的次短路径

• 到某个顶点u的最短路径加上u到v的这条边
• 到某个顶点u的次短路径加上u到v的这条边

因此要求出到所有定点的最短路径，在求最短路径的时候更新次短路径，方法思想类似于在数组中找次大值一样，因此使用呢$dijkstra$算法在更新最大值的时候进行判断，分成两种情况，如果当前的路径可有更小的路径代替，那么更新最短路径，更新的时候需要判断能否更新次短路径，因为是次短，所有要求选择的路径优于次短路径，但没有比最短路径短。（要将最短路径的节点和次短路径的都放入队列中，才能考虑到所有情况）

给出两种方法，一种是邻接表存图，一种是链式前向星存图

邻接表

#include <iostream>
#include <vector>
#include <queue>
#define N 100005
#define INF 0x3f3f3f3f
#define P pair<int, int >
using namespace std;

struct Edge {
	Edge(){}
	Edge(int _to, int _cost) : to(_to), cost(_cost){}
	int to, cost;
};
vector <Edge> g[N];
priority_queue<P, vector<P>, greater<P> > q;
int dis[N], n, r;
int dis2[N]; //存次短路径

void dijkstra(int s) {
	dis[s] = 0;
	q.push(P(0, s));
	while(!q.empty()) {
		int cur = q.top().second, d = q.top().first; q.pop();
		if(dis2[cur] < d) continue;//如果选择的路径大于当前的长度，后面不可能进行更新，直接continue
		int len = g[cur].size();
		for(int i = 0; i < len; i++) {
			Edge &e = g[cur][i];
			int d2 = e.cost + d; //通过这条边走到e.to这个顶点的长度
			if(dis[e.to] > d2) {  //优于当前最短路径，更新当前最短
				swap(d2, dis[e.to]);
				q.push(P(dis[e.to], e.to));
			}
			if(dis2[e.to] > d2 && dis[e.to] < d2) { //优于次短路径，但是比最短路长，更新次短路径
				dis2[e.to] = d2;
				q.push(P(dis2[e.to], e.to));
			}
		}
	}
}

int main() {
	ios::sync_with_stdio(0);
	int u, v, cost;
	cin >> n >> r;
	fill(dis, dis + r + 1, INF);
	fill(dis2, dis2 + r + 1, INF);
	for(int i = 1; i <= r; i++) {
		cin >> u >> v >> cost;
		g[u].push_back(Edge(v, cost));
		g[v].push_back(Edge(u, cost));
	}
	dijkstra(1);
	cout << dis2[n];
	return 0;
}

链式前向星

#include <iostream>
#include <cstring>
#include <queue>
#include <vector>
#define N 200150
#define inf 0x3f3f3f3f
#define P pair<int, int >
using namespace std;
struct Edge {
	int to, next, w;
}edge[N];

int head[N], dis1[N], dis2[N];
int cnt, n, r;

priority_queue<P, vector<P>, greater<P > > q;

inline void addEdge(int u, int v, int cost) {
	edge[++cnt].to = v;
	edge[cnt].w = cost;
	edge[cnt].next = head[u];
	head[u] = cnt;
}

void init() {
	memset(head, -1, sizeof(head));
	memset(dis1, inf, sizeof(dis1));
	memset(dis2, inf, sizeof(dis2));
}

void dijkstra(int s) {
	dis1[s] = 0;
	q.push(P(0, s));
	while(!q.empty()) {
		P t = q.top(); q.pop();
		int d = t.first, cur = t.second;
		if(dis2[cur] < d) continue;
		for(int i = head[cur]; i != - 1; i = edge[i].next) { //搜边
			int d2 = d + edge[i].w, u = edge[i].to;
			if(d2 < dis1[u]) {  //更新最短路径前更新次短路径
				dis2[u] = dis1[u];
				dis1[u] = d2;
				q.push(P(dis1[u], u)); 
			}
			if(d2 > dis1[u] && d2 < dis2[u]) { //再次判断次短路出现的情况
				dis2[u] = d2;
				q.push(P(dis2[u], u));
			}
		}
	}
}

int main() {
	ios::sync_with_stdio(0);
	init();
	int u, v, c;
	cin >> n >> r;
	for(int i = 1; i <= r; i++) {
		cin >> u >> v >> c;
		addEdge(u, v, c);
		addEdge(v, u, c);
	}
	dijkstra(1);
	cout << dis2[n];
	return 0;
}