codeup:问题 D: 最短路径

题目描述

有n个城市m条道路（n<1000, m<10000)，每条道路有个长度，请找到从起点s到终点t的最短距离和经过的城市名。

输入

输入包含多组测试数据。

每组第一行输入四个数，分别为n，m，s，t。

接下来m行，每行三个数，分别为两个城市名和距离。

输出

每组输出占两行。

第一行输出起点到终点的最短距离。

第二行输出最短路径上经过的城市名，如果有多条最短路径，输出字典序最小的那条。若不存在从起点到终点的路径，则输出“can't arrive”。

样例输入

3 3 1 3
1 3 3
1 2 1
2 3 1

样例输出

2
1 2 3

 

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
#include<cmath>
#include<stack>
#include<map>
#include<unordered_map>
#include<set>
#include<functional>
#include<string>
using namespace std;
typedef long long ll;
#define maxn 1008
struct Node {
	int v;
	int dis;
};
int n, m;
vector<Node> Adj[maxn];//邻接表
int pre[maxn];//记录到达结点v的最短路径中，v的前驱u
int d[maxn];//记录单源最短距离
int num[maxn];//记录SPFA结点入队次数
bool inq[maxn];//判断结点是否在SPFA算法的队列中
const int INF = 0x3fffffff;


//在SPFA算法中，队列中的结点是：刚刚被优化最短距离的结点，
//而优化了一个结点u的最短距离，与这个结点相连的其他结点v的最短距离就可能可以被继续优化
//所以我们遍历其他结点v，找到可以优化的结点，然后继续放进队列inQueue
bool SPFA(int s) {
	memset(inq, false, sizeof(inq));
	memset(num, 0, sizeof(num));
	fill(d, d + maxn, INF);
	for (int i = 0; i <= n; i++)
		pre[i] = i;

	queue<int> q;
	q.push(s);
	inq[s] = true;
	num[s] += 1;
	d[s] = 0;

	while (!q.empty()) {
		int u = q.front();
		q.pop();
		inq[u] = false;
		for (Node next : Adj[u]) {
			int v = next.v;
			int dis = next.dis;
			if (d[u] + dis < d[v]) {
				d[v] = d[u] + dis;//优化距离
				pre[v] = u;//记录最短路径中结点v前驱
				if (inq[v] == false) {//如果v还没有进队列，就加入队列
					q.push(v);
					inq[v] = true;
					num[v] += 1;
					if (num[v] >= n)
						return false;//存在负环，算法找不到最短距离
				}
			}
			//u < pre[v]是关键，因为题目要求找到字典最小的路径
			//所以我们要求路径长度相同的条件下，每个结点的序号尽可能小
			else if (d[u] + dis == d[v] && u < pre[v]) {
				pre[v] = u;
			}
		}
	}
	return true;
}


void DFS(int v) {
	if (pre[v] == v) {
		cout << v;
		return;
	}
	DFS(pre[v]);
	cout << " " << v;
}

void init() {
	for (int i = 0; i <= n; i++) {
		Adj[i].clear();
	}
}

int main() {
	int start, dest;
	while (cin >> n >> m >> start >> dest) {
		init();
		int u, v, dis;
		for (int i = 0; i < m; i++) {
			cin >> u >> v >> dis;
			Node next;
			next.dis = dis;

			next.v = v;
			Adj[u].push_back(next);

			next.v = u;
			Adj[v].push_back(next);
		}
		SPFA(start);
		if (d[dest] != INF) {
			cout << d[dest] << endl;
			DFS(dest);
			cout << endl;
		}
		else {
			cout << "can't arrive" << endl;
		}
	}

	return 0;
}