PAT甲级 1030 Travel Plan (30分)

1030 Travel Plan (30分)

题目链接：PAT A 1030

题目大意：题目第一行输入给出顶点数，边数，起点和终点，随后几行给出每条边的距离和通过每条边的开销，要求输出最短路径所经过的点以及这条路径的总距离以及总开销。如果有多条同样距离的路径，则输出花销最少的那条路径~

思路分析：很简单的一道dijkstra算法模板题，只要熟练掌握dijkstra算法就可以解出。有两种解法，一种是单纯的dijkstra算法，二维数组c代表每条路径的花费，cost数组代表从起点到数组下标代表的点所需要的花费，只需要新增一个pre数组记录每个点的前驱结点。当距离变小时同时更新距离，花费和前驱结点，当距离相等但是花费变小时更新花费和前驱结点，最后递归遍历pre数组即可。还有一种是dijkstra算法加dfs，核心思想是在dijkstra算法中不去统计其他的量，只统计出所有的最短路径，然后在dfs中递归遍历这些路径，统计出花销最少的量，同时也可得出最优路径。

AC代码1(dijkstra)：

#include<iostream>
#include<algorithm>
using namespace std;
const int INF = 0x7fffffff; //一个很大的数 
int n, m, s, d, g[510][510], dis[510], c[510][510], cost[510], pre[510];
bool vis[510] = {false};
void dijkstra(int s) {
	fill(dis, dis + 510, INF); //距离数组初始化 
	fill(cost, cost + 510, INF); //开销数组初始化 
	cost[s] = 0; //起点开销为0 
	dis[s] = 0; //起点距起点距离为0 
	for(int i = 0; i < n; i++) {
		int u = -1, min = INF;
		for(int j = 0; j < n; j++) { //找出离起点最近的点 
			if(dis[j] < min && vis[j] == false) {
				u = j;
				min = dis[j];
			}
		}
		if(u == -1)
			return;
		vis[u] = true;
		for(int v = 0; v < n; v++) {
			if(vis[v] == false && g[u][v] != INF) {
				if(dis[u] + g[u][v] < dis[v]) { //距离小 
					dis[v] = dis[u] + g[u][v];
					cost[v] = cost[u] + c[u][v];
					pre[v] = u; //v的前驱结点是u 
				}
				else if(dis[u] + g[u][v] == dis[v] && cost[u] + c[u][v] < cost[v]) { //距离相等但是开销小 
					cost[v] = cost[u] + c[u][v];
					pre[v] = u;
				}
			}
		}
	}
}
void print(int v) { //递归访问pre数组 
	if(v == s) {
		printf("%d ", v);
		return;
	}
	print(pre[v]);
	printf("%d ", v);
}
int main() {
	scanf("%d %d %d %d", &n, &m, &s, &d);
	fill(g[0], g[0] + 510 * 510, INF);
	int city1, city2, distance, Cost;
	for(int i = 0; i < m; i++) {
		scanf("%d %d %d %d", &city1, &city2, &distance, &Cost);
		g[city1][city2] = distance;
		g[city2][city1] = distance;
		c[city1][city2] = Cost;
		c[city2][city1] = Cost;
	}
	dijkstra(s);
	print(d);
	printf("%d %d", dis[d], cost[d]); 
	return 0;
}

AC代码2(dijkstra + dfs)：

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int INF = 1e9;
int n, m, s, d, optvalue = INF, dis[510], g[510][510], c[510][510];
bool vis[510] = {false};
vector<int> pre[510];
vector<int> path, temppath;
void dijkstra() {
	dis[s] = 0;
	for(int i = 0; i < n; i++) {
		int u = -1, min = INF;
		for(int j = 0; j < n; j++) {
			if(vis[j] == false && dis[j] < min) {
				u = j;
				min = dis[j];
			}
		}
		if(u == -1)
			return;
		vis[u] = true;
		for(int v = 0; v < n; v++) {
			if(vis[v] == false && g[u][v] != INF) {
				if(dis[u] + g[u][v] < dis[v]) {
					dis[v] = dis[u] + g[u][v];
					pre[v].clear();
					pre[v].push_back(u);
				}
				else if(dis[u] + g[u][v] == dis[v])
					pre[v].push_back(u);
			}
		}
	}
}
void DFS(int v) {
	temppath.push_back(v);
	if(v == s) {
		int value = 0;
		for(int i = temppath.size() - 1; i > 0; i--) {
			int id = temppath[i], idnext = temppath[i - 1];
			value += c[id][idnext];
		}
		if(value < optvalue) {
			optvalue = value;
			path = temppath;
		}
		temppath.pop_back();
		return;
	}
	for(int i = 0; i < pre[v].size(); i++) 
		DFS(pre[v][i]);
	temppath.pop_back();
}
int main() {
	cin >> n >> m >> s >> d;
	fill(g[0], g[0] + 510 * 510, INF);
	fill(dis, dis + 510, INF);
	int x, w, y, z;
	for(int i = 0; i < m; i++) {
		cin >> x >> w >> y >> z;
		g[x][w] = y;
		g[w][x] = y;
		c[x][w] = z;
		c[w][x] = z;
	}
	dijkstra();
	DFS(d);
	for(int i = path.size() - 1; i >= 0; i--)
		cout << path[i] << " ";
	cout << dis[d] << " " << optvalue;
	return 0;
}