迷宫寻路算法——流水算法

最新推荐文章于 2025-03-29 14:43:22 发布
最新推荐文章于 2025-03-29 14:43:22 发布
阅读量1.4k 收藏 4
点赞数
文章标签： 算法 python 广度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74555761/article/details/131866812
版权

目录

算法前提

算法思路

广度优先算法（BFS）

迷宫灌水

本算法思路

算法实现

算法输出

以下为个人拙见和粗略思考，如有宝贵建议或想法欢迎您留言或私信交流！

  • 算法前提

首先说明，该算法可进行寻路的迷宫样式需要为二维数组形式的迷宫，其中以0表示道路，以1表示墙壁，且路宽为1。如下图1。该图转化为迷宫地图可以看作图2。

                        图1                                                                                        图2

 符合上述条件的迷宫或处理成上述的迷宫便可进行该算法的本种实现。

  • 算法思路

该算法总结经验于广度优先搜索和使用水找出迷宫出路的物理实验。

  • 广度优先算法（BFS）

该算法致力于找出一个迷宫中从A到B的最短路径，思想上是每次寻得一个路口时（第一个路口除外）或走到死路时就返回到上一个路口，并选择另一方向进行探索。这样做的好处在于能尽可能大范围的探索迷宫，以来找到可能的最短路径，但同样的这样的方式带来了更大的计算量和计算时间。其算法的实现和缺点的解决在此不做具体阐述。

  • 迷宫灌水

这是一个物理实验，只要迷宫的大小、密封性等符合条件，由于水的流动性和迷宫死路导致的气压，水就可以从入口进入并找到最短的出迷宫的道路。在这个实验里我们看到的反而是在迷宫气密性不足时水会尽力探索迷宫，并且所有道路都几乎同时探索的特性。水可以找到最短出路的迷宫如下图3。水可能无法顺利找到最短出路如下图4。

                        图3                                                                                       图4

  • 本算法思路

该算法的目的在于能否减少BFS的计算量达到快速并且有效的寻找最短迷宫解的方式，那么水的这种同时流淌探索的特性可以很好的解决，同时再从迷宫的终点开始“注水”，再利用迷宫中0与1的特性，便可以实现。

在这个算法中，水便是迷宫中的某个点距离目标点的走的步数长度，因为道路均为0，可以设目标点为2，则目标点周围上下左右四个内的全部0都赋值为3，代表多一格。再将所有赋为3的点的上下左右的为0的点赋值为4，以此类推，直到赋值进行到起点为止。然后再从起点开始，根据倒序寻找出一条唯一的且最短的迷宫解。

  • 算法实现

import copy

#迷宫
maze= [
   [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
[1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,1],
[1,0,1,0,1,1,1,0,1,0,1,0,1,1,1,0,1,0,1,1,1],
[1,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1],
[1,0,1,1,1,0,1,1,1,0,1,1,1,0,1,0,1,1,1,0,1],
[1,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1],
[1,1,1,0,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1],
[1,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1],
[1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,0,1,1,1,0,1],
[1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
[1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1],
[1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1],
[1,0,1,1,1,0,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1],
[1,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1],
[1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,0,1,0,1,1,1],
[1,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1],
[1,0,1,1,1,0,1,0,1,1,1,0,1,1,1,0,1,1,1,0,1],
[1,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,1,0,1],
[1,1,1,0,1,0,1,1,1,0,1,0,1,0,1,1,1,0,1,0,1],
[1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1],
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
]
#基础参数设置
start=(19,1)
end=(1,19)
head=['right']
end_h,end_l=end

#迷宫建立
maze_value=copy.deepcopy(maze)
maze_value[end_h][end_l] = 2
list_value_now=[end]
s_h,s_l = start

# print(s_h,s_l)
value = 3 
while True:
    for value_now in list_value_now:
        v_h,v_l=value_now
        # print(v_h,v_l)
        if maze_value[v_h + 1][v_l] == 0:
            maze_value[v_h + 1][v_l] = value
        if maze_value[v_h][v_l - 1] == 0:
            maze_value[v_h][v_l - 1] = value
        if maze_value[v_h][v_l + 1] == 0:
            maze_value[v_h][v_l + 1] = value
        if maze_value[v_h - 1][v_l] == 0:
            maze_value[v_h -1][v_l] = value
    # print(maze_value)
    list_value_now=[]
    
    for i in range(21):
        for j in range(21):
            if maze_value[i][j] == value:
                list_value_now.append((i,j))
    value=value+1
    if maze_value[19][1] !=0:
        break
print("value OK")
# print(maze_value)

list_run=[start]
list_run_crossing=[]
list_run_value=[]

while True:
    now = list_run[-1]
    if now == end:
        print(list_run)
        print(list_run_crossing)
        break
    n_h,n_l = now
    # print(n_h,n_l) 
      
    list_run_value.append(maze_value[n_h - 1][n_l])    
    list_run_value.append(maze_value[n_h][n_l - 1])    
    list_run_value.append(maze_value[n_h + 1][n_l])
    list_run_value.append(maze_value[n_h][n_l + 1])
    # print(list_run_value)
    # print(maze_value[n_h][n_l])
    
    for j in range(4):    
        if list_run_value[j] - maze_value[n_h][n_l] == -1:
            flag_run = j
            
            # print(flag_run)
    list_run_value=[]
    
    if head[-1] == 'right':
        
        if flag_run == 0:
            list_run.append((n_h - 1,n_l))
            head.append('up')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("2")
                
        if flag_run == 1:
            list_run.append((n_h,n_l - 1))
            head.append('left')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("3")
        if flag_run == 2:
            list_run.append((n_h + 1,n_l))
            head.append('down')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("4")
        if flag_run == 3:
            list_run.append((n_h,n_l + 1))
            head.append('right')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("1")
        continue
    if head[-1] == 'up':
        if flag_run == 0:
            list_run.append((n_h - 1,n_l))
            head.append('up')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("1")
        if flag_run == 1:
            list_run.append((n_h,n_l - 1))
            head.append('left')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("2")
        if flag_run == 2:
            list_run.append((n_h + 1,n_l))
            head.append('down')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("3")
        if flag_run == 3:
            list_run.append((n_h,n_l + 1))
            head.append('right')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("4")
        continue
    if head[-1] == 'down':
        if flag_run == 0:
            list_run.append((n_h - 1,n_l))
            head.append('up')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("3")
        if flag_run == 1:
            list_run.append((n_h,n_l - 1))
            head.append('left')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("4")
        if flag_run == 2:
            list_run.append((n_h + 1,n_l))
            head.append('down')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("1")
        if flag_run == 3:
            list_run.append((n_h,n_l + 1))
            head.append('right')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("2")
        continue
    if head[-1] == 'left':
        if flag_run == 0:
            list_run.append((n_h - 1,n_l))
            head.append('up')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("4")
        if flag_run == 1:
            list_run.append((n_h,n_l - 1))
            head.append('left')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("1")
        if flag_run == 2:
            list_run.append((n_h + 1,n_l))
            head.append('down')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("2")
        if flag_run == 3:
            list_run.append((n_h,n_l + 1))
            head.append('right')
            if maze[n_h][n_l +1] + maze[n_h + 1][n_l] + maze[n_h - 1][n_l] + maze[n_h][n_l-1] <= 1:
                list_run_crossing.append("3")
        continue

  • 算法输出

该算法最终可以输出：

1.迷宫解的走法坐标信息2.一个普通小车的迷宫解走法信息（如左转右转）3.一个普通小车在所有拐点（如普通直角转弯、路口）的走法信息。

个人拙见，欢迎留言私信交流。

 图3图4来自：【SteveMould双语】水能自己找到迷宫出口吗？做实验试试吧_哔哩哔哩_bilibili

N0bo-dy
关注
迷宫寻路（A星寻路算法）
qq_42339210的博客
08-27 2683
题目：假设我们有一个7×5大小的迷宫，如下图所示，绿色格子表示起点，红色的格子表示终点，中间的3个深灰色格子表示障碍物。请找到一条从起点到终点最短的路径。 解题思路：        需要引入两个集合和一个公式，如下： openList：可到达的格子； closeList：已到达的格子； F=G+H； G：从起点到当前格子的步数； H：在不考虑障碍的情况下，从当前格子到达终点的距离； F：总距离，即从起点到当前格子，再从当前格子到达目
python迷宫寻路_迷宫寻路问题——A*算法
weixin_39611769的博客
12-08 3307
迷宫寻路问题——A*算法迷宫寻路问题是人工智能中的有趣问题，如何表示状态空间和搜索路径是寻路问题的重点，本文的主要内容是A*搜索算法的理解和应用，首先对基本知识和算法思想进行了解，再通过其对迷宫问题求解应用，编写 Python 程序进行深入学习。1. 搜索区域我们假设某个人要从 Start 点到达 End 点，存在墙壁把这两个点层层隔开，如下图所示，绿色部分代表起点 Start 和终点 End，红...
寻路算法--迷宫寻路
keep moving
08-18 3552
该篇文章接上篇并查集应用——生成随机迷宫, 此时已经可以生成一个任意大小的生成的迷宫        但是看起来还缺点什么，对，就是路径，没有路径怎么证明这真的是个迷宫，因此现学现用把路径加上。首先寻路算法属于图论算法，要想寻路先得有图，什么是图，这个就不细讲了，很多专门讲这个的文章，简单的说图就是一些点再加上连接这些点的边就构成了图，只要把迷宫抽象成图就能应用图论算法了。      .
迷宫问题——路径搜索（BFS,DEQUE)
最新发布
weixin_56636520的博客
03-29 773
每个方格要么是可以通过的空方格 ‘0’ ，要么是不可通过的墙方格 ‘1’，特别的，网格的四周都是墙方格，你可以沿着空方格上下左右随意移动：从 (x,y) 向上移动一格即抵达 (x−1,y)) 、向下移动一格即抵达 (x+1,y) 、向左移动一格即抵达 (x,y−1) 、向右移动一格即抵达 (x,y+1)。现在，你位于迷宫的入口 (0,0) ，想要前往终点 (h−1,w−1)。请输出一条从起点到终点的可行路径。directions = [(-1,0),(1,0),(0,1),(0,-1)]#上下左右。
迷宫寻路算法
as_314159265的专栏
09-23 1407
<br />import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Map { /** * @param args */ static int size=10; public static int [][] Maze={{0,1,0,0,0,0,0,0,0,0}, {0,1,1,1,1,0,0,0,0,0},
算法:(BFS)迷宫寻路算法
长舒的博客
03-21 5842
行远必自迩 登高必自卑 来自蓝桥杯oj 解法 这一题属于典型的迷宫搜索类题，刚入手时我也是一脸茫然，但是仔细思考了一晚上，还是勉强的解决了，这道题属于经典的BFS搜索题，解决的核心在于，如何找到迷宫出口，还有如何存储路径 解法1:BFS+路径存储 作为图论中经典的搜索算法之一，BFS算法搜索路径的特点是"层层搜索"，映射到这个题目上，给我的理解就是，使用BFS这个特点，一旦我们搜索到终点，好吧，...
C#实现4种经典迷宫生成算法和迷宫寻路算法
12-05
在IT领域，迷宫生成和寻路算法是游戏开发、路径规划、图形处理等领域中常见的问题。本项目涉及的是使用C#语言实现的4种经典迷宫生成算法和A*寻路算法。以下是对这些算法的详细解释： 1. **并查集算法生成迷宫**： ...
A*算法求解迷宫寻路问题（启发式算法）
12-04
入口坐标和出口坐标分别为(startx,starty)和(endx,eny)，每一个坐标点有两种可能：0或1，其中0表示该位置允许通过，1表示该位置不允许通过。以寻路问题为例实现A*算法的求解程序，设计两种不同的估价函数。
A*算法求解迷宫寻路问题实验
12-16
实验四 人工智能 matlab A*算法求解迷宫寻路问题实验 寻路问题常见于各类游戏中角色寻路、三维虚拟场景中运动目标的路径规划、机器人寻路等多个应用领域。迷宫寻路问题是在以方格表示的地图场景中,对于给定的起点、...
jQuery 迷宫寻路算法示例
05-12
摘要:脚本资源,Ajax/JavaScript,迷宫　迷宫寻路，基于jQuery实现，设置迷宫大小，设置算法，点击开始就可以自动寻路了。 　操作说明:左键点击设置障碍(可以拖动设置)，右键点击设置迷宫起点和终点。
流水作业（算法　代码）
10-21
对于流水作业问题，算的上是一个经典的算法了也，所以传上给大家分享
基于A*算法的迷宫寻路系统
01-25
这是一个迷宫寻路小项目。 压缩包里有已经封装好的exe文件maze.exe，双击即可运行。 源代码也在压缩包中，直接用python运行maze.py即可（python版本3.6，要装pygame） 推荐一篇介绍A 算法的博文，解释的非常好：http://blog.csdn.net/hitwhylz/article/details/23089415 求好评！！！
A*算法求解迷宫寻路问题
11-24
使用A*算法求解迷宫寻路问题，使用python编程，人工智能导论课后实验
基于JAVA的迷宫自动寻路算法实现
12-20
通过鼠标点击来获取一个目的地，然后方块自动寻路并到达目的地，提供了Keylistener借口和Runnable接口，可进行相关扩展。
迷宫自动寻路
11-24
win32 知识简单实现迷宫自动寻路,使用stack模板实现的实现的算法
迷宫寻路三大算法(BFS,DFS,A*)
热门推荐
Dog_dream的博客
05-10 2万+
迷宫寻路 这是我们的数据结构作业本加我们自己再网上找算法记录下来，不过本人比较执着画了几天时间还是把这些算法自己写出来了。总得来说网上所说的大体算法应该就有三种（BFS，DFS，A*） 这里是一个验证网址是南阳OJ的一道题这是网址 http://acm.nyist.me/problem/58 好了不说废话开始吧 BFS 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜...
流场寻路（Flow Field Path Finding）
当代野生程序猿
12-14 2632
当场景中有成千上万个寻路游戏单位需要到达同一目标点时，通过常用的A*算法进行寻路不再是合适的选择，因为每个寻路游戏单位都需要依据自身所在的位置，根据算法获得一条从自身位置寻路到目标点的路径，n个游戏单位进行寻路就需要执行n次算法，这是比较大的性能开销。而流场寻路的方式便可以很好的解决这一问题，通常用于RTS（即时战略）游戏中的群体寻路。
迷宫寻路问题——A*算法
DiamonJoy
03-24 2万+
迷宫寻路问题是人工智能中的有趣问题，如何表示状态空间和搜索路径是寻路问题的重点，本文的主要内容是A*搜索算法的理解和应用，首先对基本知识和算法思想进行了解，再通过其对迷宫问题求解应用，编写 Python 程序进行深入学习。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值