旅游规划

旅游规划

有了一张自驾旅游路线图，你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序，帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的，那么需要输出最便宜的一条路径。

输入格式:

输入说明：输入数据的第1行给出4个正整数N、M、S、D，其中N（2 ≤ N ≤ 500）是城市的个数，顺便假设城市的编号为0~(N−1)；M是高速公路的条数；S是出发地的城市编号；D是目的地的城市编号。随后的M行中，每行给出一条高速公路的信息，分别是：城市1、城市2、高速公路长度、收费额，中间用空格分开，数字均为整数且不超过500。输入保证解的存在。

输出格式:

在一行里输出路径的长度和收费总额，数字间以空格分隔，输出结尾不能有多余空格。

输入样例:

4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20

输出样例:

3 40

 

解题思路

　　这道题其实就是在Dijkstra算法的基础上进行改进。在求最短路径的基础上，再加上一个求最少费用，当然最小路径的优先级比最小费用要高，所有只有在两条路径长度相同时，才判断这两条路径哪一条所需费用最小，然后选择费用最小的那一条路径。

　　下面给出用邻接表的存图方式，以及最原始的Dijkstra算法的AC代码：

#include <cstdio>
#include <iostream>
#include <algorithm>

const int INF = 0x3f3f3f3f;

struct AdjVNode {
    int adjVer;
    int len, cost;
    AdjVNode *next;
};

struct LGraph {
    AdjVNode **G;
    int verN, edgeN;
};

LGraph *createLGraph(int n, int m);
void Dijkstra(LGraph *graph, int src, int dest);

int main() {
    int n, m, src, dest;
    scanf("%d %d %d %d", &n, &m, &src, &dest);
    LGraph *graph = createLGraph(n, m);
    Dijkstra(graph, src, dest);
    
    return 0;
}

LGraph *createLGraph(int n, int m) {
    LGraph *graph = new LGraph;
    graph->verN = n;
    graph->edgeN = m;
    graph->G = new AdjVNode*[graph->verN];
    for (int i = 0; i < graph->verN; i++) {
        graph->G[i] = NULL;
    }
    
    for (int i = 0; i < graph->edgeN; i++) {
        int v, w, len, cost;
        scanf("%d %d %d %d", &v, &w, &len, &cost);
        AdjVNode *tmp = new AdjVNode;
        tmp->adjVer = w;
        tmp->len = len;
        tmp->cost = cost;
        tmp->next = graph->G[v];
        graph->G[v] = tmp;
        
        tmp = new AdjVNode;
        tmp->adjVer = v;
        tmp->len = len;
        tmp->cost = cost;
        tmp->next = graph->G[w];
        graph->G[w] = tmp;
    }
    
    return graph;
}

void Dijkstra(LGraph *graph, int src, int dest) {
    int dist[graph->verN], cost[graph->verN];
    std::fill(dist, dist + graph->verN, INF);
    std::fill(cost, cost + graph->verN, 0);
    bool vis[graph->verN] = {false};
    
    vis[src] = true;
    dist[src] = 0;
    for (AdjVNode *w = graph->G[src]; w; w = w->next) {
        dist[w->adjVer] = w->len;
        cost[w->adjVer] = w->cost;
    }
    
    while (true) {
        int minV, min = INF;
        for (int v = 0; v < graph->verN; v++) {
            if (!vis[v] && dist[v] < min) {
                min = dist[v];
                minV = v;
            }
        }
        
        vis[minV] = true;
        if (vis[dest]) break;
        for (AdjVNode *w = graph->G[minV]; w; w = w->next) {
            if (dist[w->adjVer] > dist[minV] + w->len) {
                dist[w->adjVer] = dist[minV] + w->len;
                cost[w->adjVer] = cost[minV] + w->cost;
            }
            else if (dist[w->adjVer] == dist[minV] + w->len) {
                cost[w->adjVer] = std::min(cost[w->adjVer], cost[minV] + w->cost);
            }
        }
    }
    
    printf("%d %d\n", dist[dest], cost[dest]);
}

　　再给出我平时用std::vector来存图，同时用std::priority_queue改进后的Dijkstra算法的AC代码：

#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
#include <algorithm>

const int INF = 0x3f3f3f3f;

typedef std::pair<int, int> Pair;

struct Edge {
    int to, len, cost;
};

struct Graph {
    std::vector<std::vector<Edge> > G;
    int verN, edgeN;
};

void Dijkstra(Graph *graph, int src, int dest);

int main() {
    int n, m, src, dest;
    scanf("%d %d %d %d", &n, &m, &src, &dest);
    Graph *graph = new Graph;
    graph->verN = n;
    graph->edgeN = m;
    graph->G.resize(graph->verN);
    for (int i = 0; i < graph->edgeN; i++) {
        int v, w, len, cost;
        scanf("%d %d %d %d", &v, &w, &len, &cost);
        graph->G[v].push_back({w, len, cost});
        graph->G[w].push_back({v, len, cost});
    }
    
    Dijkstra(graph, src, dest);
    
    return 0;
}

void Dijkstra(Graph *graph, int src, int dest) {
    int dist[graph->verN], cost[graph->verN];
    std::fill(dist, dist + graph->verN, INF);
    std::fill(cost, cost + graph->verN, INF);
    bool vis[graph->verN] = {false};
    std::priority_queue<Pair, std::vector<Pair>, std::greater<Pair> > pq;
    dist[src] = cost[src] = 0;
    pq.push(Pair(0, src));
    
    while (!pq.empty()) {
        int v = pq.top().second;
        pq.pop();
        if (vis[v]) continue;
        vis[v] = true;
        if (vis[dest]) break;
        
        for (std::vector<Edge>::iterator it = graph->G[v].begin(); it != graph->G[v].end(); it++) {
            if (!vis[it->to] && dist[v] + it->len < dist[it->to]) {
                dist[it->to] = dist[v] + it->len;
                cost[it->to] = cost[v] + it->cost;
                pq.push(Pair(dist[it->to], it->to));
            }
            else if (!vis[it->to] && dist[v] + it->len == dist[it->to]) {
                cost[it->to] = std::min(cost[v] + it->cost, cost[it->to]);
            }
        }
    }
    
    printf("%d %d", dist[dest], cost[dest]);
}