1030. Travel Plan (30) dijkstra算法

最新推荐文章于 2020-04-21 15:29:29 发布

Lost_in_wine

最新推荐文章于 2020-04-21 15:29:29 发布

阅读量356

点赞数

CC 4.0 BY-SA版权

分类专栏：图论 PATA

本文链接：https://blog.youkuaiyun.com/Lost_in_wine/article/details/50103399

PATA 同时被 2 个专栏收录

55 篇文章

订阅专栏

图论

7 篇文章

订阅专栏

本文介绍了如何使用变形的Dijkstra算法解决给定城市地图中从起点到终点的最短路径问题，同时考虑了路径的成本。通过实例分析，详细解释了算法的实现过程和步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1030. Travel Plan (30)

时间限制

400 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

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

Sample Output

0 2 3 3 40

提交代码

题意：给定n个点，m条边，给定每条边的距离，花费，求源点到目的地距离最短的路径，如果存在多条，输出花费最小的那条。

题解：Dijkstra算法的变形。

#include <cstdio>
#include <cstring>

const int N = 510;
const int INF = 0x3f3f3f3f;
int maze[N][N], cost[N][N], pre[N];
int dist[N], ct[N];
int n;

void Dijkstra(int src, int dest) {
    bool vis[N];
    memset(vis, false, sizeof(vis));

    vis[src] = true;
    for (int i = 0; i < n; ++i) {
        dist[i] = maze[src][i];
        ct[i] = cost[src][i];
        pre[i] = src;
    }
    dist[src] = ct[src] = 0;
    for (int i = 0; i < n; ++i) {
        int tmp_dist = INF;
        int tmp_cost = INF;
        int k;
        for (int j = 0; j < n; ++j) {
            if (vis[j] == false) {
                if (dist[j] < tmp_dist) {
                    tmp_dist = dist[j];
                    tmp_cost = ct[j];
                    k = j;
                }
                else if (dist[j] == tmp_dist && ct[j] < tmp_cost) {
                    tmp_cost = ct[j];
                    k = j;
                }
            }
        }
        vis[k] = true;
        for (int j = 0; j < n; ++j) {
            if (vis[j] == false) {
                if (dist[j] > dist[k] + maze[k][j]) {
                    dist[j] = dist[k] + maze[k][j];
                    ct[j] = ct[k] + cost[k][j];
                    pre[j] = k;
                }
                else if (dist[j] == dist[k] + maze[k][j] && ct[j] > ct[k] + cost[k][j])
                    ct[j] = ct[k] + cost[k][j], pre[j] = k;
            }
        }
    }
}

void find_path(int src, int cur) {
    if (src == cur) {
        printf("%d ", src);
        return ;
    }
    find_path(src, pre[cur]);
    printf("%d ", cur);
}

int main() {
    int m, src, dest;
    scanf("%d%d%d%d", &n, &m, &src, &dest);

    memset(maze, INF, sizeof(maze));
    memset(cost, INF, sizeof(cost));
    for (int i = 0; i < m; ++i) {
        int u, v, d, c;
        scanf("%d%d%d%d", &u, &v, &d, &c);
        if (maze[u][v] > d) {
            maze[u][v] = maze[v][u] = d;
            cost[u][v] = cost[v][u] = c;
        }
        else if (maze[u][v] == d && cost[u][v] > c)
            cost[u][v] = cost[v][u] = c;
    }

    memset(pre, -1, sizeof(pre));
    Dijkstra(src, dest);
    find_path(src, dest);
    printf("%d %d\n", dist[dest], ct[dest]);

    return 0;
}