HDU 3790 最短生成树 (最短路）

题目链接

Problem Description

给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。

Input

输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点。n和m为0时输入结束。

(1<n<=1000, 0<m<100000, s != t)

Output

输出 一行有两个数， 最短距离及其花费。

Sample Input

3 2
1 2 5 6
2 3 4 5
1 3
0 0

Sample Output

9 11

分析：

简单的最短路径问题，但是我们需要额外考虑的就是，最短路径可能不止一条，所以在找到最短路径的同时，还要保证花费最少。

代码

#include<stdio.h>
#include<string.h>
using namespace std;
#define inf 0x1f1f1f1f
int a[1005][1005];///路径长度
int b[1005][1005];///花费
int d[1005];
int p[1005];
int v[1005];
int n,m;
void init(int n)///初始化
{
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
        {
            a[i][j]=inf;
            b[i][j]=inf;
        }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        if(n==0||m==0)break;
        init(n);
        int x,y,z,q;
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d%d",&x,&y,&z,&q);
            if(a[x][y]==inf)///还没有路径，直接赋值
            {
                a[x][y]=a[y][x]=z;
                b[x][y]=b[y][x]=q;
            }
            else
            {
                if(a[x][y]>z||a[x][y]==z&&b[x][y]>q)///原来有路径，但是路径长；或则路径虽然一样，但是花费多
                {
                    a[x][y]=a[y][x]=z;
                    b[x][y]=b[y][x]=q;
                }
            }
        }
        int s,t;
        scanf("%d%d",&s,&t);
        memset(v,0,sizeof(v));
        memset(p,0,sizeof(p));
        for(int i=1; i<=n; i++)
        {
            d[i]=inf;
            p[i]=inf;
        }
        //要点1 初始化起点为0.
        /*zhongdian*/d[s]=0;///路径
        /*zhongdian*/p[s]=0;///花费
        //表示s是起点
        for(int i=1; i<=n; i++) ///我们将要所有点.
        {
            int w,m=inf,t;
            for(int j=1; j<=n; j++)
            {
                if(v[j]==0&&d[j]<m)///先找到目前最短路径~
                {
                    w=j;
                    m=d[j];
                    t=p[j];
                }
                if(v[j]==0&&d[j]==m&&p[j]<t)///再找到最短的花费
                {
                    w=j;
                    m=d[j];
                    t=p[j];
                }
            }
            v[w]=1;///做标记，表明你这个点已经走过
            for(int j=1; j<=n; j++)
            {
                if(d[w]+a[w][j]<d[j])///到j的路径能够通过当前最短路径进行权值压缩.就要进行压缩
                {
                    d[j]=d[w]+a[w][j];
                    p[j]=p[w]+b[w][j];
                }
                if(d[w]+a[w][j]==d[j])
                {
                    if(p[j]>p[w]+b[w][j])
                    {
                        p[j]=p[w]+b[w][j];
                    }
                }
            }
        }
        printf("%d %d\n",d[t],p[t]);
    }
}