数据结构实验之图论七：驴友计划

数据结构实验之图论七：驴友计划

Time Limit: 1000ms   Memory limit: 65536K  有疑问？点这里^_^

题目描述

做为一个资深驴友，小新有一张珍藏的自驾游线路图，图上详细的标注了全国各个城市之间的高速公路距离和公路收费情况，现在请你编写一个程序，找出一条出发地到目的地之间的最短路径，如果有多条路径最短，则输出过路费最少的一条路径。

输入

连续T组数据输入，每组输入数据的第一行给出四个正整数N,M，s，d，其中N(2 <= N <= 500)是城市数目，城市编号从0～N-1，M是城市间高速公路的条数，s是出发地的城市编号，d是目的地的城市编号；随后M行，每行给出一条高速公路的信息，表示城市1、城市2、高速公路长度、收费额，中间以空格间隔，数字均为整数且不超过500，输入数据均保证有解。 

输出

在同一行中输出路径长度和收费总额，数据间用空格间隔。 

示例输入

1
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

提示

 

来源

迪杰斯特拉算法求最短路

#include<bits/stdc++.h>
using namespace std;
#define MAX 550
#define INF 0x3f3f3f
struct node
{
    int L,W;
}Map[MAX][MAX];//用邻接矩阵表示图，图中每个元素含两个值L,W;L为路径长度，W为收费情况
int visit[MAX];
int path[MAX]; //储存路径长度
int weight[MAX];//储存收费情况
int Dijkstar(int n,int s,int d)//迪杰斯特拉算法
{
    int k;
    for(int i=0;i<n;i++)//初始化
    {
        path[i]=Map[s][i].L;//将与S点有连线的顶点初始化其路径长度，即权值
        weight[i]=Map[s][i].W;//将与0点有连线的顶点加上费用值，也看做权值
    }
    path[s]=0;
    visit[s]=1;
    for(int i=1;i<n;i++)//开始主循环，每次求得s到某个n顶点的最短路径
    {
        int Min = INF;
        for(int j=0;j<n;j++)
        {
            if(!visit[j]&&path[j]<Min)
            {
                k=j;
                Min = path[j];
            }
        }
            visit[k]=1;//将目前找到的最近的顶点置1

            for(int i=0;i<n;i++)//修正当前路径
            {
                if(!visit[i]&&Map[k][i].L<INF)
                {
                    if(path[k]+Map[k][i].L<path[i])//以当前点为起点寻找下一个最短路
                    {
                        path[i]=path[k]+Map[k][i].L;
                        weight[i]=weight[k]+Map[k][i].W;
                    }
                    else if(path[k]+Map[k][i].L==path[i])//若存在相同路径，则比较相同路径上费用和的大小，选择小的存入weight数组
                    {
                        if(weight[k]+Map[k][i].W<weight[i])
                        {
                            weight[i]=weight[k]+Map[k][i].W;
                        }
                    }
                }
            }
    }
    cout<<path[d]<<" "<<weight[d];
    cout<<endl;
    return 0;
}
int main()
{
    int n,m,s,d;
    int u,v,l,w;
    int t;
    cin>>t;
    while(t--)
    {
        for(int i=0;i<MAX;i++) //邻接矩阵初始化，将不存在在的边赋值为无穷大
        {
            visit[i]=0;
            for(int j=0;j<MAX;j++)
            {
                Map[i][j].L=Map[i][j].W=INF;
            }
        }
        cin>>n>>m>>s>>d;
        while(m--)
        {
            cin>>u>>v>>l>>w;
            Map[u][v].L=Map[v][u].L=l;
            Map[u][v].W=Map[v][u].W=w;
        }
        Dijkstar(n,s,d);
    }
    return 0;
}

Floyed算法求最短路

#include<bits/stdc++.h>
using namespace std;
#define MAX 550
#define INF 0x3f3f3f
struct node
{
    int L,W;
}Map[MAX][MAX];

int D[MAX][MAX];//储存任意两点间的最短路
int path[MAX][MAX];//储存要到达顶点的前驱顶点
int weight[MAX][MAX];//储存任意两点间的最小费用

int Floyed(int n,int s,int d)//Floyed算法求最短路
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            D[i][j]=Map[i][j].L;
            weight[i][j]=Map[i][j].W;
            path[i][j]=-1;
        }
    }

    for(int k=0;k<n;k++)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(D[i][j]>D[i][k]+D[k][j])
                {
                    D[i][j]=D[i][k]+D[k][j];
                    weight[i][j]=weight[i][k]+weight[k][j];
                    path[i][j]=k;
                }
                else if(D[i][j]==D[i][k]+D[k][j]) //若存在相同路径，选择费用较小的一条
                {
                    if(weight[i][j]>weight[i][k]+weight[k][j])
                    {
                        weight[i][j]=weight[i][k]+weight[k][j];
                        path[i][j]=k;
                    }
                }

            }
        }
    }
    /*用于输出测试*/
    /*
    *输出要达到顶点的前驱
    */
   /* for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            cout<<path[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<"*************"<<endl;
    */

    /*
    *用于输出最短路
    */
    /*for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            cout<<D[i][j]<<" ";
        }
        cout<<endl;
    }*/
    cout<<D[s][d]<<" "<<weight[s][d]<<endl;
    return 0;
}
int main()
{
    int n,m,s,d;
    int u,v,l,w;
    int t;
    cin>>t;
    while(t--)
    {
        for(int i=0;i<MAX;i++) //邻接矩阵初始化，将不存在在的边赋值为无穷大
        {
            for(int j=0;j<MAX;j++)
            {
                Map[i][j].L=Map[i][j].W=INF;
            }
        }
        cin>>n>>m>>s>>d;
        while(m--)
        {
            cin>>u>>v>>l>>w;
            Map[u][v].L=Map[v][u].L=l;
            Map[u][v].W=Map[v][u].W=w;
        }
        Floyed(n,s,d);
    }
    return 0;
}

参考来源： http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html