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

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

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

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

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

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
Sample Output

3 40
（较能理解最后一个为解释版）

#include <iostream>
#include <bits/stdc++.h>
#define inf 0x3f3f3f3f

using namespace std;

int b,c,d,e;
int n[510][510];
int m[510][510];
int disv[510];
int mi[510];
int flag[510];

void bigboom(int a,int b,int c)
{
    int i,j,s;
    for(i=1; i<=a; i++)
    {
        disv[i]=n[i][b];
        mi[i]=m[i][b];
    }
    disv[b]=0;
    mi[b]=0;
    flag[b]=1;
    for(i=1;i<a;i++)
    {
        int t=inf;
        for(j=1;j<=a;j++)
        {
            if(flag[j]==0&&disv[j]<t)
            {
                t=disv[j];
                s=j;
            }
        }
        flag[s]=1;
        int k;
        for(k=1;k<=a;k++)
        {
            if(flag[k]==0)
            {
                if(disv[k]>disv[s]+n[k][s])
                {
                    disv[k]=disv[s]+n[k][s];
                    mi[k]=mi[s]+m[k][s];
                }
                else if(disv[k]==disv[s]+n[k][s]&&mi[k]>mi[s]+m[k][s])
                {
                    mi[k]=mi[s]+m[k][s];
                }
            }
        }
    }
    cout << disv[c] << " " << mi[c] << endl;
}

int main()
{
    int a,i,z,u,v,w;
    cin >> a;
    while(a--)
    {
        memset(n,inf,sizeof(n));
        memset(disv,0,sizeof(disv));
        memset(flag,0,sizeof(flag));
        cin >> b >> c >> d >> e;
        for(i=1; i<=b; i++)
        {
            n[i][i]=0;
        }
        while(c--)
        {
            cin >> z >> u >> v >> w;
            n[z][u]=n[u][z]=v;
            m[z][u]=m[u][z]=w;
        }
        bigboom(b,d,e);
    }
    return 0;
}

（前向星+SPFA）（暂时小编还是不懂）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<queue>
using namespace std;
const int M=550;
const int N=550;
const int inf=0x3f3f3f3f;
int head[M],vis[M],cnt,n,m,dis[M],fee[M];
struct EDGE
{
    int to,w,next,fe;
} edge[N];
void add(int u,int v,int w,int fe)
{
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].fe=fe;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
struct node
{
    int dis,num;
    bool operator<(const node&b)const
    {
        return dis>b.dis;
    }
}d[M];
void Dijkstra(int s,int e)
{
    for(int i=1;i<=n;i++)
    {
        vis[i]=0;
        d[i].num=i;
        d[i].dis=inf;
        fee[i]=inf;
    }
    d[s].dis=0;
    fee[s]=0;
    priority_queue<node>q;
    q.push(d[s]);
    while(!q.empty())
    {
        int v=q.top().num;
        vis[v]=1;
        q.pop();
        for(int i=head[v];~i;i=edge[i].next)
        {
            int to=edge[i].to,w=edge[i].w,fe=edge[i].fe;
            if(d[to].dis>d[v].dis+w||d[to].dis==d[v].dis+w)
            {
                if(d[to].dis>d[v].dis+w)
                {
                    d[to].dis=d[v].dis+w;
                    fee[to]=fee[v]+fe;
                }
                else
                {
                    if(fee[to]>fee[v]+fe)
                    {
                        fee[to]=fee[v]+fe;
                    }
                }
                q.push(d[to]);
            }
        }
    }
    printf("%d %d\n",d[e].dis,fee[e]);
}
//void SPFA(int s,int e)
//{
//    for(int i=0; i<=n; i++)
//    {
//        vis[i]=0;
//        dis[i]=inf;
//        fee[i]=inf;
//    }
//    dis[s]=0;
//    fee[s]=0;
//    queue<int>q;
//    vis[s]=1;
//    q.push(s);
//    while(!q.empty())
//    {
//        int v=q.front();
//        q.pop();
//        vis[v]=0;
//        for(int i=head[v]; ~i; i=edge[i].next)
//        {
//            int to=edge[i].to,w=edge[i].w,fe=edge[i].fe;
//            if(dis[to]>dis[v]+w||dis[to]==dis[v]+w)
//            {
//                if(dis[to]>dis[v]+w)
//                {
//                    dis[to]=dis[v]+w;
//                    fee[to]=fee[v]+fe;
//                }
//                else
//                {
//                    if(fee[to]>fee[v]+fe)
//                    {
//                        fee[to]=fee[v]+fe;
//                    }
//                }
                printf("!\n");
//                if(!vis[to])
//                {
//                    vis[to]=1;
//                    q.push(to);
//                }
//            }
//        }
//    }
//    printf("%d %d\n",dis[e],fee[e]);
//}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int s,e;
        cnt=0;
        scanf("%d%d%d%d",&n,&m,&s,&e);
        for(int i=0;i<n;i++)
        {
            head[i]=-1;
        }
        while(m--)
        {
            int u,v,w,fe;
            scanf("%d%d%d%d",&u,&v,&w,&fe);
            add(u,v,w,fe);
            add(v,u,w,fe);
        }
        Dijkstra(s,e);
    }
    return 0;
}

（第一种方法的解释版）

#include<bits/stdc++.h>
#define MAX INT_MAX //int型里面最大的数

using namespace std ;

int n , m ; //顶点数，边数;

int Map[550][550] ; //存放点与点之间的权值;

int vis[550] ; //点的访问情况 ;

int money[550][550] ; //存放点与点之间的过路费 ;


void Dijkstra(int n , int v0, int vn)
{
    int dist[550] ; //存放v0到vn的最短路径 ;
    int mon[550] ;
    for(int i=0;i<n;i++)
    {
        dist[i] = Map[v0][i] ; //每个点的最短路径都设为与起点相连边上的权值，（不与起点相连的点dist[]数组的值为MAX）
        mon[i] = money[v0][i] ;//每个点的过路费都初始化成与起点v0相连边上的费用。
    }
    vis[v0] = 1 ;  //---->|
    dist[v0] = 0 ;    //  |---->对起点的初始化。
    mon[v0] = 0 ; //----->|
    for(int i=1;i<n;i++) //除了起点一共n-1个点 ;
    {
        int MIN = MAX  ; //先取一个无穷大的数，可以方便以后的替换其他的值;
        int k = v0 ; //记录最短路径相关点的下标;
        for(int j=0 ; j<n ; j++) //找出与起始点相连最短的路径;
        {
            if(vis[j]==0&&dist[j]<MIN) //如果这个点没有被访问过，而且这个点的最短路径比min小；（这个循环的作用是找出与起点v0相连的点所形成的边，那个边的权值最小（最短路径最短））
            {
                MIN = dist[j]  ;
                k = j ;
            }
        }
        vis[k] = 1 ; //改变相关点访问状态;
        int j ;
        for(j=0;j<n;j++)
        {
            if(vis[j]==0&&Map[k][j]<MAX) //如果这个点没被访问过。而且这个点j与点k之间存在边的话（Map[k][j]<MAX意思是k，j之间有边连接）
            {
                if(Map[k][j]+dist[k]<dist[j]) //这个点与k点的路径+起点v0到k的最短路径 < 起点v0到j的最短路径
                {
                     dist[j] = Map[k][j] + dist[k] ;
                     mon[j] = mon[j] + money[k][j] ;
                }
                else if(dist[k]+Map[k][j]==dist[j]&&mon[k]+money[k][j]<mon[j]) //路径相同，钱不同 ；
                {
                    mon[j] = mon[j] + Map[k][j] ;
                }
            }
        }
    }
    printf("%d %d\n",dist[vn],mon[vn]) ;
}

int main()
{
    int  t ;
    scanf("%d",&t) ;
    while(t--)
    {
        int v0 , vn ;
        scanf("%d %d %d %d",&n,&m,&v0,&vn);
        int i , j ;
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                if(i==j)
                    Map[i][j] = 0 ;
                else
                    Map[i][j] = MAX ;
            }
        }
        memset(vis,0,sizeof(vis)) ;
        int u , v , t , s ;
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d %d",&u,&v,&t,&s);
            Map[u][v] = Map[v][u] = t ;
            money[u][v] = money[v][u] = s ;
        }
        Dijkstra(n,v0,vn) ;
    }
    return 0 ;
}