Dijkstra算法初步 - 迷宫问题

本文介绍了一种基于迪杰斯特拉算法解决迷宫游戏中最短路径问题的方法,旨在找到从起点到终点的最快路径及最大得分。文章通过具体实例展示了如何使用邻接矩阵和迭代过程来实现这一算法。
你来到一个迷宫前。该迷宫由若干个房间组成,每个房间都有一个得分,第一次进入这个房间,你就可以得到这个分数。还有若干双向道路连结这些房间,你沿着这些道路从一个房间走到另外一个房间需要一些时间。游戏规定了你的起点和终点房间,你首要目标是从起点尽快到达终点,在满足首要目标的前提下,使得你的得分总和尽可能大。现在问题来了,给定房间、道路、分数、起点和终点等全部信息,你能计算在尽快离开迷宫的前提下,你的最大得分是多少么?
Input
第一行4个整数n (<=500), m, start, end。n表示房间的个数,房间编号从0到(n - 1),m表示道路数,任意两个房间之间最多只有一条道路,start和end表示起点和终点房间的编号。
第二行包含n个空格分隔的正整数(不超过600),表示进入每个房间你的得分。
再接下来m行,每行3个空格分隔的整数x, y, z (0<z<=200)表示道路,表示从房间x到房间y(双向)的道路,注意,最多只有一条道路连结两个房间, 你需要的时间为z。
输入保证从start到end至少有一条路径。
Output
一行,两个空格分隔的整数,第一个表示你最少需要的时间,第二个表示你在最少时间前提下可以获得的最大得分。
Input示例
3 2 0 2
1 2 3
0 1 10
1 2 11
Output示例
21 6


---------------------------------------------------我是分割线^_^-------------------------------------------------



此题为迪杰斯特拉算法的基础题,用来了解单源最短路径的求法,其实一开始的入门都是在
《啊哈!算法》这本书中看到的,最短路径问题,这个题可以使用
邻接表和优先队列做,但
我都没用,我用了效率比较低下的二维数组,不过也有被难倒的地方,就是在计算最大分数
的时候,被卡了有几个小时都找不到错误
后来发现原来是因为相等的情况多余了,要注意最
小最大和最长最短的一些限制条件,以后写的时候要提醒自己注意= =。


#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;

#define Int __int64
#define INF 0x3f3f3f3f

const int MAXN = 555;
int n, m, s, e;

int maze[MAXN][MAXN];
int dis[MAXN];
bool vis[MAXN];
int score[MAXN];
int ans[MAXN];

void init() {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) maze[i][j]  = 0;
            else maze[i][j] = INF;
        }
    }
    memset(dis, 0, sizeof(dis));
    memset(vis, false, sizeof(vis));
    memset(ans, false, sizeof(ans));
}

void Dijkstra() {
    for (int i = 0; i < n; i++) {
        scanf("%d", &score[i]);
    }

    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d %d %d", &u, &v, &w);
        if (w < maze[u][v]) {
            maze[u][v] = w;
            maze[v][u] = w;
        }
    }

    for (int i = 0; i < n; i++) {
        dis[i] = maze[s][i];
        if (i != s) ans[i] = score[s] + score[i];//初始化的时候也要判断等于的情况
        else ans[i] = score[i];
    }

    for (int i = 0; i < n; i++) {

        int pos, Min = INF;
        for (int a = 0; a < n; a++) {
            if (vis[a]) continue;
            

转载于:https://www.cnblogs.com/steamedbun/p/5751190.html

好的,我理解您的问题是关于使用Dijkstra算法解决迷宫问题的Python实现。下面是一个简单的示例代码,希望能对您有所帮助: ```python import heapq def dijkstra(maze, start, end): # 迷宫中可行走的四个方向 directions = [(0, 1), (0, -1), (1, 0), (-1, 0)] m, n = len(maze), len(maze[0]) # 初始化距离矩阵 distance = [[float('inf')] * n for _ in range(m)] distance[start[0]][start[1]] = 0 # 初始化堆 heap = [(0, start)] while heap: d, node = heapq.heappop(heap) if node == end: return d if distance[node[0]][node[1]] < d: continue for direction in directions: x, y = node[0] + direction[0], node[1] + direction[1] if 0 <= x < m and 0 <= y < n and maze[x][y] == 0: new_d = d + 1 if new_d < distance[x][y]: distance[x][y] = new_d heapq.heappush(heap, (new_d, (x, y))) return -1 # 无法到达终点 ``` 其中,`maze`是迷宫矩阵,0表示可走,1表示墙壁;`start`和`end`分别是起点和终点的坐标,例如`(0, 0)`表示左上角。 这段代码使用了堆优化的Dijkstra算法来求出起点到终点的最短距离。具体实现过程是: 1. 初始化距离矩阵,起点的距离为0,其余点的距离为无穷大; 2. 将起点加入堆中,并以起点为起点,开始向四周扩展; 3. 如果新扩展的点可以到达且距离更短,则更新距离,并将其加入堆中; 4. 重复2-3步骤,直到堆为空或者找到了终点。 最后,如果找到了终点,返回起点到终点的最短距离;否则,说明无法到达终点,返回-1即可。 希望这个示例代码对您有所帮助!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值