PAT(甲级)1030 Travel Plan(带两个权值的最短路）

A traveler’s map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path between his/her starting city and the destination. If such a shortest path is not unique, you are supposed to output the one with the minimum cost, which is guaranteed to be unique.

Input Specification:

Each input file contains one test case. Each case starts with a line containing 4 positive integers N, M, S, and D, where N (<=500) is the number of cities (and hence the cities are numbered from 0 to N-1); M is the number of highways; S and D are the starting and the destination cities, respectively. Then M lines follow, each provides the information of a highway, in the format:

City1 City2 Distance Cost

where the numbers are all integers no more than 500, and are separated by a space.

Output Specification:

For each test case, print in one line the cities along the shortest path from the starting point to the destination, followed by the total distance and the total cost of the path. The numbers must be separated by a space and there must be no extra space at the end of output.

Sample Input
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
0 2 3 3 40

一道模板题，直接套路Dijkstra就行了，不过这里有两个权值，即距离相同时优先输出花费最小的那个路，故采用邻接表存图，然后再用pre[]记录前趋点就可以输出路径和花费了

完整代码如下：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<vector>
#include<set>
#include<queue>
using namespace std;
const int MAX = 510;
const int INF = 99999999;
pair<int,int> dis[MAX];//first代表距离，second代表花费
bool used[MAX];
int pre[MAX];
struct Edge{
    int to,d,cost;
};
vector<Edge> G[MAX];
int n,m,b,o;
void Dijkstra(int a){
    for(int i=0;i<n;i++){
        dis[i].first = dis[i].second = INF;//这里是更新为INF，我竟然刚开始把他更新为0真是囧。
        used[i] = false;
        pre[i] = -1;
    }
    dis[a].first = dis[a].second = 0;//更新起点
    while(true){
        int v = -1;
        for(int u=0;u<n;u++){
            if(used[u])
                continue;
        /*优先选择距离小的，如果距离相等优先选择花费小的*/
            if(v == -1 || ((dis[u].first < dis[v].first) || (dis[u].first == dis[v].first && dis[u].second < dis[v].second)))
                v = u;
        }
        if(v == -1) break;//如果这个点没有更新就证明所有点都已经使用过了，就跳出。

        used[v] = true;
        for(vector<Edge>::iterator it = G[v].begin();it != G[v].end();++it){//便利这个点的所有边，这里要用vector的迭代器
            if(dis[it->to].first > dis[v].first + it->d){
                pre[it->to] = v;//如果发生距离更新，就更新前趋点。
                dis[it->to].first = dis[v].first + it->d;//这里距离和花费都要更新.
                dis[it->to].second = dis[v].second + it->cost;
            }
            else if(dis[it->to].first == dis[v].first + it->d && dis[it->to].second > dis[v].second + it->cost){
                pre[it->to] = v;
                dis[it->to].second = dis[v].second + it->cost;
            }
        }
    }
}
int main(void)
{
    cin >> n >> m >> b >> o;
    int x,y;
    Edge e;
    for(int i=0;i<m;i++){
        cin >> x >> y >> e.d >> e.cost;
        e.to = y;
        G[x].push_back(e);
        e.to = x;
        G[y].push_back(e);
    }
    Dijkstra(b);
    int step[MAX],top = 0;
    step[++top] = o;
    int k = pre[o];
    while(k != -1){
        step[++top] = k;
        k = pre[k];
    }
    for(int i=top;i>=1;i--){//输出路径
        cout << step[i] << " ";
    }
    cout << dis[o].first << " " << dis[o].second;
    return 0;
}