1030 Travel Plan

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 D are 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条道路，并给出M条道理的距离属性与花费属性。现在给定起点S与终点D。求从起点到终点的最短路径，最短距离以及花费。注意：如果有多条最短路径，则选择花费最小的那条。

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXN=510;//最大顶点数
const int INF=100000000;//无穷大
//n为顶点数,m为边数，st起点，ed终点
//G为距离矩阵，const为花费矩阵
//d[]记录最短距离，minCost记录最短路径上的最小花费
int n,m,st,ed,G[MAXN][MAXN],cost[MAXN][MAXN];
int d[MAXN],minCost=INF;
bool vis[MAXN]={false};//vis[i]==true表示顶点i已访问
vector<int> pre[MAXN];
vector<int> tempPath,path;//临时路径，最优路径
void Dijkstra(int s)
{
	//s为起点
	fill(d,d+MAXN,INF);
	d[s]=0;//起点s到达自身的距离为0
	for(int i=0;i<n;i++)
	{
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++)
		{
			//找到未访问的顶点中d[]最小的
			if(vis[j]==false && d[j]<MIN)
			{
				u=j;
				MIN=d[j];
			} 
		}
		//找不到小于INF的d[u],说明剩下的顶点和起点不连通
		if(u==-1) return;
		vis[u]=true;//标记u为已访问
		for(int v=0;v<n;v++)
		{
			//如果v未访问&& u能到达v
			if(vis[v]==false && G[u][v]!=INF)
			{
				if(d[u]+G[u][v]<d[v])
				{
					//以u为中介点使d[v]更小
					d[v]=d[u]+G[u][v];//优化d[v] 
					pre[v].clear(); //清空pre[v]
					pre[v].push_back(u);//u为v的前驱 
				}else if(d[u]+G[u][v]==d[v])
				{
					//找到相同长度的路径
					pre[v].push_back(u);//u为v的前驱之一 
				}
			} 
		} 
	} 
}
void DFS(int v)
{//v为当前结点 
	if(v==st)
	{//递归边界，到达叶子结点（路径起点）
	   tempPath.push_back(v);
	   int tempCost=0;//记录当前路径的花费之和
       for(int i=tempPath.size()-1;i>0;i--)
	   {
   	    //当前结点id,下个结点idNext
		   int id=tempPath[i],idNext=tempPath[i-1];
		   tempCost+=cost[id][idNext];//增加边id->idNext的边权
		    
       } 
       if(tempCost<minCost)
       {
       	//如果当前路径的边权之和更小
		  minCost=tempCost;//更新minCost
		  path=tempPath;//更新path 
       }
       tempPath.pop_back();
       return;	
	}
	  tempPath.push_back(v);
	  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]+MAXN*MAXN,INF);
	fill(cost[0],cost[0]+MAXN*MAXN,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;
}