7-9 旅游规划（25 分）（Dijkstra最短路径算法）

有了一张自驾旅游路线图，你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序，帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的，那么需要输出最便宜的一条路径。

输入格式:

输入说明：输入数据的第1行给出4个正整数N、M、S、D，其中N（2≤N≤500）是城市的个数，顺便假设城市的编号为0~(N−1)；M是高速公路的条数；S是出发地的城市编号；D是目的地的城市编号。随后的M行中，每行给出一条高速公路的信息，分别是：城市1、城市2、高速公路长度、收费额，中间用空格分开，数字均为整数且不超过500。输入保证解的存在。

输出格式:

在一行里输出路径的长度和收费总额，数字间以空格分隔，输出结尾不能有多余空格。

输入样例:

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

输出样例:

3 40

解题思路：1、很明显这是一个图的问题，但是它有两个权值，因而我用了一个三元数组来存储数据

2、又因其是单源最短路径，因而使用Dijkstra算法

3、其次注意一下如果最短距离相同还要判断费用是否最小

4、最后还要小心0也算是一个城市

 #include<stdio.h>
 #include<stdlib.h>

 #define MAXVEX 505
 #define INFINITY  65535

 void CreateGraph( );
 void Dijkstra( int v);

 int G[MAXVEX][MAXVEX][],Nv,Ne;
 int know[MAXVEX];        //know[]=1表示求得最短路径
 int distance[MAXVEX];   //表示求的最短距离
 int pay[MAXVEX];       //表示最少费用
 //int P[MAXVEX];        //存储最短路径的下标

 int main()
 {
     int s,d;
     scanf("%d %d %d %d",&Nv,&Ne,&s,&d);
     CreateGraph();
     Dijkstra(s);
     if( distance[d]<INFINITY ){
         printf("%d %d",distance[d],pay[d]);
     }

     return ;
 }

 void CreateGraph()
 {
     //用邻接矩阵表示图
     int i,j;
     int v1,v2;
     int dn,f;  //dn表示距离，f表示费用

     for( i=; i<Nv; i++)
     {
         for( j=; j<Nv; j++)
         {
             G[i][j][] = INFINITY;  //初始化
             G[i][j][] = INFINITY;
         }
     }

     for( i=; i<Ne; i++)  //注意这里是读入边
     {
         scanf("%d %d %d %d",&v1,&v2,&dn,&f);
         G[v1][v2][] = G[v2][v1][]=dn;
         G[v1][v2][] = G[v2][v1][]=f;
     }
 }

 void Dijkstra( int v)
 {
     //求从v结点到其他各结点的最短距离
     int i,j,k;
     int min,cost;

     for( i=; i<Nv; i++)
     {
         know[i] =;
         distance[i] =G[v][i][];   //将与v点有连接的结点加上距离
         pay[i] =G[v][i][];
     }

     know[v] = ;
     distance[v] =;   //V到V距离为0
     pay[v] = ;

     for( i=; i<Nv; i++)
     {
         min = INFINITY;     //当前所知离v结点的最近距离
         for( j=; j<Nv; j++)
         {
             //寻找离v结点的最近距离
             if( !know[j] && distance[j]<min)
             {
                 k = j;
                 min = distance[j];
                 cost = pay[j];
             }
         }

         know[k] = ;
         for( j=; j<Nv; j++)
         {
             //修正最短路径和距离
             if( !know[j] && (min+G[k][j][]<distance[j]))
             {
                 distance[j] = min+G[k][j][];
                 pay[j] = cost + G[k][j][];

             }
             else if( !know[j] && (min+G[k][j][]==distance[j]) && (cost+G[k][j][] < pay[j]))
             {

                 pay[j] = cost + G[k][j][];
             }
         }

     }

 }

以上是用邻接矩阵存储的，还有一种方法是使用邻接表来实现，以下是用C++写的，个人感觉更容易理解一些，空间复杂度也小一些

 #include<stdio.h>
 #include<queue>
 #include<vector>
 using namespace std;

 struct E
 {
     int next;
     int cost;
     int dis;
 };
 vector<E> edge[];
 bool mark[];
 int dis[];
 int cost[];

 int main()
 {
     int n,m,S,T;  //起点终点
     int i,j;
     E temp;
     int newP;
     while( scanf("%d%d%d%d",&n,&m,&S,&T)!=EOF)
     {
         if( n== && m==) break;

         for( i=; i<=n; i++)
         {
             edge[i].clear();   //初始化邻接链表
             dis[i] = -;
             mark[i] = false;
             cost[i] = ;
         }
         while( m--)
         {
             int a,b,d,c;
             scanf("%d%d%d%d",&a,&b,&d,&c);
             temp.cost = c;
             temp.next = b;
             temp.dis = d;
             edge[a].push_back(temp);
             temp.next = a;
             edge[b].push_back(temp);  //无向图，故每条边信息都要添加到两个顶点的单链表中
         }

         dis[S] = ;
         mark[S] = ;
         newP = S;  //起点为s
         for( i=; i<n; i++)
         {
             for( j=; j<edge[newP].size(); j++)
             {
                 //更新一个顶点对它的边表内结点的距离
                 int next = edge[newP][j].next;
                 int c = edge[newP][j].cost;
                 int d = edge[newP][j].dis;
                 if( mark[next]==true) continue;
                 if( dis[next]==- || dis[next]>dis[newP]+d
                         || ((dis[next]==dis[newP]+d) &&(cost[next]>cost[newP]+c)))
                 {
                     dis[next] = dis[newP]+d;
                     cost[next] = cost[newP]+c;
                 }
             }
             int minx = ;
             for( j=; j<=n; j++)
             {
                 //寻找这个顶点出发的最小值
                 if( mark[j]==true) continue;
                 if( dis[j]==-) continue;
                 if( dis[j]<minx)
                 {
                     minx = dis[j];
                     newP = j;
                 }
             }
             mark[newP] = true;
         }
         printf("%d %d\n",dis[T],cost[T]);
     }
     return ;
 }