1030 Travel Plan （30 分)

1030 Travel Plan （30 分)

A traveler's map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path between his/her starting city and the destination. If such a shortest path is not unique, you are supposed to output the one with the minimum cost, which is guaranteed to be unique.

Input Specification:

Each input file contains one test case. Each case starts with a line containing 4 positive integers N, M, S, and D, where N (≤500) is the number of cities (and hence the cities are numbered from 0 to N−1); M is the number of highways; S and Dare the starting and the destination cities, respectively. Then M lines follow, each provides the information of a highway, in the format:

City1 City2 Distance Cost

where the numbers are all integers no more than 500, and are separated by a space.

Output Specification:

For each test case, print in one line the cities along the shortest path from the starting point to the destination, followed by the total distance and the total cost of the path. The numbers must be separated by a space and there must be no extra space at the end of output.

Sample Input:

4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20

Sample Output:

0 2 3 3 40

题意:给出n个城市,m条路,，路有距离和花费两个属性。打印出起点到终点的最短路径，以及最短路径的距离及花费，如果存在多条最短路，则选择花费最小的最短路。

思路:dijkstra和dfs。打印最短路径和求最小边权的题都是比较套路的。

细节:dfs计算边权的和时，注意只需要访问n-1条边，因此如果是倒着访问，那么循环条件应为i>0,如果正着讨论，循环条件为i<tempPath.size() -1.

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const int maxn=510;
const int INF=99999999;
int G[maxn][maxn],d[maxn],cost[maxn][maxn],minCost=INF;//G为距离矩阵，cost为花费矩阵，d最短距离，minCost最小花费 
bool vis[maxn];
vector<int> pre[maxn];//前驱 
vector<int> tempPath,path;
int n,m,st,ed;

void dijkstra(int st)
{
	fill(d,d+maxn,INF);
	d[st]=0;
	for(int i=0;i<n;i++){
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++){
			if(vis[j]==false&&d[j]<MIN){
				u=j;
				MIN=d[j];
			}
		}
		if(u==-1){
			return ;
		}
		vis[u]=true;
		for(int v=0;v<n;v++){
			if(d[u]+G[u][v]<d[v]){
				d[v]=d[u]+G[u][v];
				pre[v].clear();
				pre[v].push_back(u);
			}
			else if(d[u]+G[u][v]==d[v]){
				pre[v].push_back(u);
			}
		}
	}
}

void dfs(int v)
{
	tempPath.push_back(v);
	if(v==st){//递归边界为起始点 
		int tempCost=0;
		for(int i=tempPath.size()-1;i>0;i--){//没有等号，倒着访问 
			int id=tempPath[i],nextid=tempPath[i-1];//当前结点和下一个结点 
			tempCost+=cost[id][nextid];
		}
		if(tempCost<minCost){
			minCost=tempCost;
			path=tempPath;
		}
		tempPath.pop_back();
		return ;
	}
	for(int i=0;i<pre[v].size();i++){
		dfs(pre[v][i]);
	}
	tempPath.pop_back();
}

int main()
{
	scanf("%d %d %d %d",&n,&m,&st,&ed);
	int u,v;
	fill(G[0],G[0]+510*510,INF);
	fill(cost[0],cost[0]+510*510,INF);
	for(int i=0;i<m;i++){
		scanf("%d %d",&u,&v);
		scanf("%d %d",&G[u][v],&cost[u][v]);
		G[v][u]=G[u][v];
		cost[v][u]=cost[u][v];
	}
	dijkstra(st);
	dfs(ed);
	for(int i=path.size()-1;i>=0;i--){
		printf("%d ",path[i]);
	}
	printf("%d %d\n",d[ed],minCost);
	return 0;
}