数据结构实验之图论七:驴友计划(Dijkstra+SPFA+Floyd)

数据结构实验之图论七:驴友计划
Time Limit: 1000 ms Memory Limit: 65536 KiB

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
Hint

Source
xam

Dijkstra+SPFA

#include
#include
#include
#include
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_queueq;
    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;
//    queueq;
//    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;i1;
        }
        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;
}

Floyd:

#include
#include
#include
#include
using namespace std;
const int inf=0x3f3f3f3f;
int e[505][505],dis[505][505];
int n,m;
void Floyd(int s,int z)
{
    for(int k=0; kfor(int i=0; ifor(int j=0; jif(e[i][j]>e[i][k]+e[k][j]||e[i][j]==e[i][k]+e[k][j])
                {
                    if(e[i][j]>e[i][k]+e[k][j])
                    {
                       e[i][j]=e[i][k]+e[k][j];
                       dis[i][j]=dis[i][k]+dis[k][j];
                    }
                    else
                    {
                        if(dis[i][j]>dis[i][k]+dis[k][j])
                        {
                            dis[i][j]=dis[i][k]+dis[k][j];
                        }
                    }
                }
            }
        }
    }
    printf("%d %d\n",e[s][z],dis[s][z]);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int s,z;
        scanf("%d%d%d%d",&n,&m,&s,&z);
        for(int i=0;ifor(int j=0;jif(i==j)
                {
                    e[i][j]=0;
                    dis[i][j]=0;
                }
                else
                {
                    e[i][j]=inf;
                    dis[j][i]=inf;
                }
            }
        }
        for(int i=1;i<=m;i++)
        {
            int x,y,w,z;
            scanf("%d%d%d%d",&x,&y,&w,&z);
            e[x][y]=w;
            e[y][x]=w;
            dis[x][y]=z;
            dis[y][x]=z;
        }
        Floyd(s,z);
    }
    return 0;
}

你可能感兴趣的:(分界线重新开始,图re,2018年暑假集训)