杭电3790————最短路问题

最短路径问题

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 14059    Accepted Submission(s): 4310

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

 

这个问题其实并不难，重点在于什么时候更新花费。（PS：我比较喜欢用Dijkstra算法，它的原理这里就不详细说了，其实就是典型的贪心思想。）

在更新结点时，常规的最短路算法我们只考虑要加入的点是不是距离最小的，并没有考虑费用的问题。

那么有了费用，我们的问题是什么时候才会去更新费用呢？

分析：

如果说从起点start到node有多条路径都是最短的，那么就只存储保证最短路的同时，价值更小的那个路径经过的结点。

这样说可能不太明白，不过一看代码就显而易见了。

#include <iostream>
#include <cstdio>
#include <cstring>
#define maxn 1005
#define INF 0xffffff
using namespace std;
int G[maxn][maxn];
int V[maxn][maxn];
int n,m;

int Min(int x,int y)
{
    return (x < y) ? x : y;
}
void init()
{
    for(int i = 0 ; i <= n ; ++i){
        for(int j = 0 ; j <= n ; ++j){
            G[i][j] = INF;
            V[i][j] = INF;
        }
    }
}
void Dijkstra(int s,int e)
{
    int intree[maxn];
    int mindist[maxn],minvalue[maxn];
    int dist,value,pos;

    memset(intree,0,sizeof(intree));
    for(int i = 1 ; i <= n ; ++i){
        mindist[i] = G[s][i];
        minvalue[i] = V[s][i];
    }
    intree[s] = 1;
    for(int node = 1 ; node <= n-1 ; ++node){//剩余节点数
        dist = INF;
        value = INF;
        for(int i = 1 ; i <= n ; ++i){
            if(!intree[i])
                if(mindist[i] < dist || (mindist[i] == dist && minvalue[i] < value)){//优先考虑路径最短
                dist = mindist[i];
                value = minvalue[i];
                pos = i;
            }
        }
        intree[pos] = 1;
        //update
        for(int i = 1 ; i <= n ; ++i){
            int tempdist = mindist[pos] + G[pos][i];
            int tempvalue = minvalue[pos] + V[pos][i];
            if(!intree[i])
                if(tempdist < mindist[i] || (mindist[i] == tempdist && tempvalue < minvalue[i])){
                    mindist[i] = tempdist;
                    minvalue[i] = tempvalue;
                }
        }

    }
    printf("%d %d\n",mindist[e],minvalue[e]);
};
int main()
{
    int v1,v2,v,len;
    int s,e;

    while(scanf("%d%d",&n,&m) != EOF){
        if(n == 0 && m == 0)
            break;
        init();
        while(m--){
            scanf("%d%d%d%d",&v1,&v2,&len,&v);
            if(G[v1][v2] > len){
                G[v1][v2] = G[v2][v1] = len;
                V[v1][v2] = V[v2][v1] = v;
            }
        }
        scanf("%d%d",&s,&e);
        Dijkstra(s,e);
    }
    return 0;
}