旅游规划

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

输入格式:

输入说明：输入数据的第1行给出4个正整数NN、MM、SS、DD，其中NN（2\le N\le 5002≤N≤500）是城市的个数，顺便假设城市的编号为0~(N-1N−1)；MM是高速公路的条数；SS是出发地的城市编号；DD是目的地的城市编号。随后的MM行中，每行给出一条高速公路的信息，分别是：城市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

/************************************************************************************************************/
本程序是对dijkstra算法的应用，由于在题目中显示的是有两个权重的表示，首先必须要保证有最短的路径，在查看图中是否有多条具有相同最短路径，在其中选择最低的消费。

本程序采用邻接链表的形式，当在有多条相同路径中，只在图中标记起始点的邻接边中的顶点。

/*由于在这其中的过程中涉及到dijkstra，并且出现两条相等的路径的算法，如果*/
/*在运算的过程中采用邻接链表的方式用dijkstra*/

#include<iostream>
#include<malloc.h>
using namespace std;

#define INF (100000)
#define MAX 100
//如果采用邻接链表的形式构造图，在每一个顶点中接下存储的边是其相邻的边
typedef struct _Edge{
    int Adjv;
    int Weight;
    int costValue;

    _Edge *Next;
}Edge,nedge;

typedef struct _VNode
{
    int  NodeName;
    bool flag;
    nedge *first_edge;
}VNode;

typedef struct _Graph{
    int Vernum;
    int Edgnum;
    VNode G[MAX];

}MGraph;

MGraph *Graph;

void link_last(nedge *list, nedge *node)
{  nedge *p=list;
while(p->Next!=NULL)
{
    p=p->Next;
}
p->Next=node;
node->Next=NULL;
}

MGraph *BuildMyGraph(int N,int M)
{     MGraph *pG;
    pG=(MGraph*)malloc(sizeof( _Graph));

    pG->Vernum=N;pG->Edgnum=M;

    //将点初始化
    for(int i=0;i<N;i++)
    {
        pG->G[i].NodeName=i;
        pG->G[i].flag=false;
        pG->G[i].first_edge=NULL;
    }
            //输入数据
      int c1,c2,w1,cost1,i,j;
    Edge *edge;
    for(i=0;i<pG->Edgnum;i++)
    {
        cin>>c1>>c2>>w1>>cost1;
        edge=(Edge*)malloc(sizeof(_Edge));
        edge->Adjv=c2;edge->Weight=w1;edge->costValue=cost1;edge->Next=NULL;
        for(j=0;j<pG->Vernum;j++)
        {
            if(c1==pG->G[j].NodeName)
            {
                if(pG->G[j].first_edge==NULL)
                {
                    pG->G[j].first_edge=edge;
                }
                else
                {
                    link_last(pG->G[j].first_edge,edge);
                }
            }
        }
    }
    return pG;
}
int get_weight(int b,int a)
{
    Edge *egd=Graph->G[b].first_edge;
    int min=INF;
    if(b==a)
    {
        return 0;
    }
    while(egd!=NULL)
    {
        if(a==egd->Adjv)
        {
            if(egd->Weight<min)
            {
                min=egd->Weight;
            }
        }
        egd=egd->Next;
    }
    return min;
}

int  Path(int prev[],int v,int e )
{    int cost=0; Edge *item;
    //输出最短路径同时Graph标记号已经走过的点
    int i=0,j=0; int rev[MAX];

    for(i=e ;i!=v ; i=prev[i])
    {
            rev[j++]=i;
            if(prev[i]==v)
             Graph->G[i].flag=true;//只把与起始点相邻的定点进行标记
    }
    rev[j]=v;
    for(j;j>0;j--)
    {    int t=j-1;
        item=Graph->G[rev[j]].first_edge;
        {
            while(item!=NULL)
            {
                if(rev[t]==item->Adjv)
                    {  cost=cost+item->costValue;
                         break;
                }
                item=item->Next;
            }
        }
    }

    return cost;
}

int dijkstra(int begin,int end,int *path)
{//保证循环过程中begin和end所在点不能被标记
    int prev[MAX],dist[MAX],flag[MAX]; int path_cost;

    int i ,j ,k=begin;

    for(i=0;i<Graph->Vernum;i++)
    {
        flag[i]=0;
        prev[i]=-1;
        dist[i]=get_weight(begin ,i);

    }

    for(i=0;i<Graph->Vernum;i++)
    {
        if(dist[i]!=INF)
        {
            prev[i]=0;
        }
    }

flag[begin]=1;
dist[begin]=0;
int min,tmp;
//开始进行dijkstra计算
for(i=1;i<Graph->Vernum;i++)
{
    min=INF;
    for(j=0;j<(*Graph).Vernum;j++)
    {
        if(Graph->G[j].first_edge!=NULL)
        {
            if(dist[j]<min &&  !flag[j]  && Graph->G[j].flag==false)
            {
                min=dist[j];
                k=j;
            }
        }
    }
        flag[k]=1;
        //更新prev和dist矩阵
        for(j=0;j<Graph->Vernum;j++)
        {
            tmp=get_weight(k,j);
             tmp = (tmp==INF ? INF : (min + tmp));
             if(!flag[j] && (tmp<dist[j]) && Graph->G[j].flag==false)
             {
                 dist[j]=tmp;
                 prev[j]=k;
             }
        }
    }

    //dijkstra把起始点到各个顶点的最短路径，但是我们只需要从起始点到终点的路径就行了
            if(dist[end]!=INF)
            {
                *path=dist[end];
              path_cost=    Path( prev,begin,end );
            }
　　　　　　　else
　　　　　　　　　　{
　　　　　　　　　　　　return -1;
　　　　　　　　　　　　}

    return path_cost;
}
int main()
{
    
    int N,M,W,D;
    cin>>N>>M>>W>>D;
    
    Graph=BuildMyGraph(N,M);
    
    int cout=0;
    for(int i=0;i<Graph->Vernum;i++)
    {
        if(W==Graph->G[i].NodeName)
        { Edge *item=Graph->G[i].first_edge;
            while(item!=NULL)
            {
                cout++;
                item=item->Next;
            }
        }
    }

    int path_cost=0,temp=INF;
    int path=0,temp_path=INF;
    //接下来对图进行dijkstra算法研究
    for(int j=0;j<cout;j++)
    {
        path_cost=dijkstra(W,D,&path);
    　　　　if(path_cost==-1)
　　　　　　　　　　{
　　　　　　　　　　　　printf("没有最短路径\n");
　　　　　　　　　　　　　　exit(0);
　　　　　　　　　　　　}

        Graph->G[D].flag=false;
        if(temp_path>=path)
        {
            temp_path=path;
         if(temp>=path_cost)
         {
             temp=path_cost;
        }
        }
        else
        {
            printf("%d %d",D,temp);
            return 0;
            break;
        }
        
    }
     return 0;
}

同时结果的显示：