PAT 甲级 1030 Travel Plan（二尺度最短路径问题）

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

题目大意

给出n个城市和m条路，每条路有距离和对应的费用。给定起点和终点，请输出距离最短并且花费最少的一条路，以及这条路所经过的城市（距离最短时，花费最少的路唯一）

分析

经典的二尺度最短路径问题。

第一尺度是距离最短，第二尺度是花费最少。

可以使用Dijkstra算法，找到最短距离，然后顺带记录最短路径上的最少花销（因为这题仅有二种尺度，并且不存在两个尺度都一致的情况）

使用pre[]数组记录每个点的前驱结点，然后通过DFS来输出这条路径。

不过我自己比较傻，路径数忘记放for循环里了，导致找了很久的错...

如果实在搞不明白自己哪个测试点为什么会出错，可以上牛客网搜一搜原题。牛客网测试点数据是可见的，方便自己测试。

#include <bits/stdc++.h>
using namespace std;

const int maxn=510;
const int inf=1e7;
struct Edge{
    int to,dis,cost;
    Edge(int a,int b,int c):to(a),dis(b),cost(c){}
};

struct Point{
    int num,dis;
    Point(int a,int b):num(a),dis(b){}
    bool operator < (const Point k) const{
        return dis>k.dis;
    }
};
vector<Edge> g[maxn];
bool vis[maxn]={false};
int dis[maxn],cost[maxn],pre[maxn];
void Dijkstra(int s){
    fill(dis,dis+maxn,inf);
    fill(cost,cost+maxn,inf);
    fill(vis,vis+maxn,false);
    priority_queue<Point> q;
    dis[s]=0;
    cost[s]=0;
    vis[s]=true;
    q.push(Point(s,0));
    while(!q.empty()){
        Point now=q.top();
        int u=now.num;
        q.pop();
        //if(vis[u]) continue;
        vis[u]=true;
        for(int i=0;i<g[u].size();++i){
            int v=g[u][i].to;
            int w=g[u][i].dis;
            int c=g[u][i].cost;
            if(!vis[v]){
              if(dis[u]+w<dis[v]){
                  dis[v]=dis[u]+w;
                  cost[v]=cost[u]+c;
                  q.push(Point(v,dis[v]));
                  pre[v]=u;
               }else if(dis[u]+w==dis[v] && cost[v]>cost[u]+c){
                  pre[v]=u;
                  cost[v]=cost[u]+c;
               }
            }
        }
    }
}

void DFS(int v,int st){
    if(v==st){
        printf("%d ",v);
        return;
    }
    DFS(pre[v],st);
    printf("%d ",v);
}

int main(){
    int n,m,s,d;
    cin >> n >> m>> s>>d;
    for(int i=0;i<m;++i){
        int from,to,dis,cost;
        cin >>from>>to>>dis>>cost;
        g[from].push_back(Edge(to,dis,cost));
        g[to].push_back(Edge(from,dis,cost));
    }
    Dijkstra(s);
    DFS(d,s);
    printf("%d %d",dis[d],cost[d]);
    return 0;
}