迷宫寻路算法---深度优先算法(的魔改版)(基于python)

最新推荐文章于 2022-02-07 10:19:15 发布
最新推荐文章于 2022-02-07 10:19:15 发布
阅读量2.5k 收藏 41
点赞数 6
分类专栏： 算法学习 文章标签： 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ghost_him/article/details/116309224
版权

深度优先搜索 迷宫生成 寻路算法 Python实现 路径规划
关键词由CSDN通过智能技术生成

总体目录

  1. 这篇文章里用到的迷宫生成算法的讲解:迷宫生成算法—深度优先算法(基于python)_ghost_him的博客-CSDN博客
    建议先看上面的那一篇文章,这篇文章在上面的文章的基础上写的

  2. 首先你能用上文的代码生成这样子的迷宫在这里插入图片描述
    ,那么接下来就开始了.

版权及协议声明

本文章遵循CC BY-NC-SA 4.0协议,即知识共享-署名-非商业性使用-相同方式共享

更加舒服的阅读方式

该文章的pdf版,排版更舒服(其实是因为不会csdn的排版)
文章的pdf版:
链接：https://pan.baidu.com/s/19y-vcSSyCPr5b22cXd3jLw
提取码：2233
代码:
链接：https://pan.baidu.com/s/1Nfj-CZMyU1T0Gz2n2TjXRw
提取码：2233

一. 深度优先算法的原理与思路(上一篇文章的原话,看过的可以直接跳过)

首先来看一下算法导论上的解释：

深度优先搜索总是对最近才发现的结点v的出发边进行探索，直到该结点的所有出发边都被发现为止。一但结点v的所有出发边都被发现，搜索则“回溯”到v的前驱结点（v是经过该结点才被发现的），来搜索该前驱结点的出发边。该过程一直持续到从源结点可以达到的所有结点都被发现为止。如果还存在尚未发现的结点，则深度优先搜索将从这些未被发现的结点中任选一个作为新的源点，并重复同样的搜索过程。该算法重复整个过程，直到图中的所有结点都被发现为止。

用人话的方式来说明：

  1. 选一个起点
  2. 查看周围能够移动的点并随即挑一个移动
  3. 重复步骤2直到周围没有可以移动的点
  4. 回溯一格，即回到到当前位置的上一个位置，并执行步骤2和3

二. 在迷宫中的实现

寻路算法与生成算法是有不同的,生成算法找的是”墙”,而寻路算法找的是路,而且是紧密相连的路.
众所周知,在一个已经生成好的迷宫中,1.每一条路都是与周围的路紧密相连的2.每一条路都有且仅有一条途径到另一条路上

因此在代码中,我们只需要检测路周围四周的格子,如果周围有两条路那么就在探测出来的新的路(即之前未被检测过的路)上重复这个动作,直到周围只有一条路的时候停止这个动作.

以下图为例:
在这里插入图片描述
蓝色为当前执行代码的方块,绿色为回溯的方块(即上一个方块),黄色为检测到的方块
首先从起点开始在这里插入图片描述
蓝色周围有一个未被检测过的方块,
那么接下来就应该在黄色的方块上执行这个相同的操作:在这里插入图片描述
直到碰到岔路口,那么就是一种新的情况:在这里插入图片描述
这部分就是我的算法与深度优先算法的不同之处了:

在这个情况下,我是同时在两个黄色的方块上执行相同的操作,而不是从中挑一条先走到底再挑两外的一条路走: 在这里插入图片描述

接下来就是相当于运行了两个方法来继续运行,直到每条路都走到尽头了: 在这里插入图片描述
那么就有一个问题:如果遇到了终点怎么办?

我们先设迷宫的终点在右下角: 在这里插入图片描述
由于边界处的墙最多只能与一条路紧密连接,因此只需要设这个终点旁边的路为终点方块即可.

由上面的寻路的过程中,我们可以知道,每个路都是指向上一条路的,从而最终指向起点在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
因此只需要一个递归,就能够将这些路的属性全部设置好,最后就能输出了.

三. 用代码来实现

完整的代码

import time
import random
import sys

#===setting==========
width_set =int(input("请输入宽度"))
height_set = int(input("请输入高度"))
Ischeck = str(input("是否要查看生成过程(Y/N)"))
IsFind =str(input("是否要寻找路径(Y/N)"))
sys.setrecursionlimit(3000)
#=====test=======
if Ischeck !='Y' and Ischeck !='N':
    print("你输入的是:"+Ischeck)
    print("请重新输入Y/N")
    sys.exit()
if IsFind !='Y' and IsFind !='N':
    print("你输入的是:"+IsFind)
    print("请重新输入Y/N")
    sys.exit()
if width_set<4 or height_set<4:
    width_set=11
    height_set=11
    print("输入的尺寸过小,已自动调节成,宽度:11,高度:11")
if width_set%2 !=1:
    width_set +=1
    print("宽度请输入奇数,已自动矫正为:"+str(width_set))
if height_set%2 !=1:
    height_set +=1
    print("高度请输入奇数,已自动矫正为:"+str(height_set))

class cube:
    loc_x=0#当前的x坐标
    loc_y=0#当前的y坐标
    from_x = 0
    from_y = 0
    IsEndpoints = False
    IsWay = False
    Iswall = True#是否是墙
    Iscalled = False#是否被使用过

time_before = time.time()
map = [[0 for width in range(width_set)] for height in range(height_set)]

def initial():
    #初始化地图并记录自身的坐标
    for height in range(0,height_set):
        for width in range(width_set):
            map[height][width] = cube()
            map[height][width].loc_y = height
            map[height][width].loc_x = width

    #初始化起始点
    map[1][0].Iswall = False
    map[1][1].from_x = 0
    map[1][1].from_y = 1

    #=======================初始化边框=========================
    for height in range(0,height_set-1):
         for width in range(width_set-1):
            if(height == 0 or height == width_set-1):
                map[height][width].Iscalled = True
            else:
                map[height][0].Iscalled = True
                map[height][width_set-1].Iscalled = True

def printmap():
    out=""
    for height in range(height_set):
        for width in range(width_set):
            if map[height][width].Iswall ==True:
                out = out+"■ "
            elif map[height][width].IsWay ==True:
                out = out+". "
            elif map[height][width].IsEndpoints ==True:
                out = out+"* "
            else:
                out = out +"  "
                
            if width == width_set-1:
                out = out +"\n"
    print(out)

def spawn(local_map=[]):
    Waypoints_ing =[]#当函数运行时用来添加备选路点
    width = local_map.loc_x
    height = local_map.loc_y

    map[height][width].Iswall = False
    if width>2:#判断左边的格子
        if map[height][width-2].Iswall == True:
            Waypoints_ing.append(map[height][width-2])
            map[height][width-2].from_x = width
            map[height][width-2].from_y = height

    if height>2:#判断上边的格子
        if map[height-2][width].Iswall == True:
            Waypoints_ing.append(map[height-2][width])
            map[height-2][width].from_x = width
            map[height-2][width].from_y = height

    if width<width_set-2:#判断下边的格子
        if map[height][width+2].Iswall == True:
            Waypoints_ing.append(map[height][width+2])
            map[height][width+2].from_x = width
            map[height][width+2].from_y = height

    if height<height_set-2:#判断上边的格子
        if map[height+2][width].Iswall == True:
            Waypoints_ing.append(map[height+2][width])
            map[height+2][width].from_x = width
            map[height+2][width].from_y = height

    if(local_map.from_x !=0 and local_map.from_y!=0):
        map[int((local_map.from_y+height)/2)][int((local_map.from_x+width)/2)].Iswall = False
    if(len(Waypoints_ing)>0):#如果有元素
        if Ischeck == "Y":
            printmap()
        targetnum = random.randint(0,len(Waypoints_ing)-1)#生成一个关于Waypoints_ing的随机的下标
        spawn(Waypoints_ing[targetnum])#进行下一次的递归
    else:
        if map[height][width].from_y ==1 and map[height][width].from_x==0:#如果回溯的目标为初始点的时候
            return#从递归中跳出
        spawn(map[map[height][width].from_y][map[height][width].from_x])#如果不是初始点,那么就在回溯目标的格子上继续递归

def DoFindway(local_map = []):
    width = local_map.loc_x
    height = local_map.loc_y
    map[height][width].Iscalled = True
    if width>0:
        if map[height][width-1].IsEndpoints ==True:
            spawmWay(map[height][width])

        if map[height][width-1].Iswall == False and map[height][width-1].Iscalled == False:
            map[height][width-1].from_y = height
            map[height][width-1].from_x = width
            DoFindway(map[height][width-1])
           
    if height>0:
        if map[height-1][width].IsEndpoints  == True:
            spawmWay(map[height][width])

        if map[height-1][width].Iswall == False and map[height-1][width].Iscalled == False:
            map[height-1][width].from_y = height
            map[height-1][width].from_x = width
            DoFindway(map[height-1][width])
        

    if width<width_set-1:
        if map[height][width+1].IsEndpoints  == True:
            spawmWay(map[height][width])

        if map[height][width+1].Iswall == False and map[height][width+1].Iscalled == False:
            map[height][width+1].from_y = height
            map[height][width+1].from_x = width
            DoFindway(map[height][width+1])
           
    if height<height_set-1:
        if map[height+1][width].IsEndpoints  == True:
            spawmWay(map[height][width])

        if map[height+1][width].Iswall == False and map[height+1][width].Iscalled ==False:
            map[height+1][width].from_y = height
            map[height+1][width].from_x = width
            DoFindway(map[height+1][width])
        
#记录路径点
def spawmWay(local_map = []):
    width = local_map.loc_x
    height = local_map.loc_y
    map[height][width].IsWay = True
    '''
    print("跟踪:("+str(height)+","+str(width)+")")
    print("跟踪from:("+str(local_map.from_y)+","+str(local_map.from_x)+")")
    '''
    if local_map.from_x !=0 or local_map.from_y !=1:
        spawmWay(map[local_map.from_y][local_map.from_x])
    

def findWay():
    for height in range(1,height_set-1):
        for width in range(1,width_set-1):
            map[height][width].Iscalled = False
    print("寻找路径中")
    DoFindway(map[1][1])
    print("路径寻找完毕")
   
print(map)
initial()
spawn(map[1][1])
printmap()
if IsFind =="Y":
    map[1][1].IsWay = True
    map[height_set-2][width_set-1].IsEndpoints = True
    map[height_set-2][width_set-1].Iswall = False
    findWay()
printmap()

首先,根据以上的分析,我们需要对格子添加一些新的属性:是否是墙,是否被使用过,是否是终点
因此要在class类里添加三个属性

class cube:
    loc_x=0#当前的x坐标
    loc_y=0#当前的y坐标
    from_x = 0
    from_y = 0
    IsEndpoints = False#是否是终点
    IsWay = False
    Iswall = True#是否是墙
    Iscalled = False#是否被使用过

检测路的存在与否

首先是与之前的思路一样的:
以检测左边的格子是不是路为例:
如果,要保证检测左边的格子不会报错,那么就说明左边是有格子可以检测的,那么就可以推断出:当前的位置不在地图的最左侧,即:width>0
那么,我们要检测左边的格子的时候就要保证当前的格子不是最左边的格子,那么就需要一下的代码进行判断

if width>0:

好,现在已经说明了当前的格子不是最左边的格子了,那么我们就可以开始检测左边的格子是不是终点,如果是,那么就直接做路径的回溯:

if map[height][width-1].IsEndpoints ==True:
         spawmWay(map[height][width])#在接下来会讲到,这个函数是用来做路径的回溯的

如果不是终点,那么就要判断左边的格子是不是墙,如果是墙就直接跳过,如果不是墙,那么就要判断左边的路有没有被检测过(即是不是刚才的路,要避免死循环),如果没有被检测过,那么就在这个没被检测过的路上进行检测

if map[height][width-1].Iswall == False and map[height][width-1].Iscalled == False:
#将左边方块的回溯方块的坐标指向当前的方块,说明是从当前的方块传递到左边的方块的
       map[height][width-1].from_y = height
       map[height][width-1].from_x = width
       DoFindway(map[height][width-1])#这个方法就是现在在讲的方法,当前的代码会在最后封装成DoFindway()方法

其余三向的检测都是一个道理

if width>0:#检测左边的格子
        if map[height][width-1].IsEndpoints ==True:
            spawmWay(map[height][width])

        if map[height][width-1].Iswall == False and map[height][width-1].Iscalled == False:
            #将左边方块的回溯方块的坐标指向当前的方块,说明是从当前的方块传递到左边的方块的
            map[height][width-1].from_y = height
            map[height][width-1].from_x = width
            DoFindway(map[height][width-1])
           
    if height>0:#检测上面的格子
        if map[height-1][width].IsEndpoints  == True:
            spawmWay(map[height][width])

        if map[height-1][width].Iswall == False and map[height-1][width].Iscalled == False:
            map[height-1][width].from_y = height
            map[height-1][width].from_x = width
            DoFindway(map[height-1][width])
        

    if width<width_set-1:#检测右边的格子
        if map[height][width+1].IsEndpoints  == True:
            spawmWay(map[height][width])

        if map[height][width+1].Iswall == False and map[height][width+1].Iscalled == False:
            map[height][width+1].from_y = height
            map[height][width+1].from_x = width
            DoFindway(map[height][width+1])
           
    if height<height_set-1:#检测下面的格子
        if map[height+1][width].IsEndpoints  == True:
            spawmWay(map[height][width])

        if map[height+1][width].Iswall == False and map[height+1][width].Iscalled ==False:
            map[height+1][width].from_y = height
            map[height+1][width].from_x = width
            DoFindway(map[height+1][width])

接下来,我们要将这个代码封装起来
为了让我们写代码的时候比较方便,所以我将这个方法里的width设定为当前格子的x,height设置为当前格子的y

def DoFindway(local_map = []):
    width = local_map.loc_x
    height = local_map.loc_y

并且,每一次执行这个方法的时候都说明当前的格子已经被检测过了,因此,

  map[height][width].Iscalled = True

最后,这个方法就写完了

关于找到终点以后寻找回起点的问题

其实这个方法很简单:首先先将当前的方块设置为路径,再判断当前的方块的上一个方块是不是起点,如果不是,那就在上一个方块再次执行当前的方法.如果是,那么就停止当前的递归.

def spawmWay(local_map = []):#输入一个格子
    width = local_map.loc_x
    height = local_map.loc_y
    map[height][width].IsWay = True#将当前的方块设置为路径点
    '''
    print("跟踪:("+str(height)+","+str(width)+")")
    print("跟踪from:("+str(local_map.from_y)+","+str(local_map.from_x)+")")
    '''
    if local_map.from_x !=0 or local_map.from_y !=1:#(1,0)为初始点的坐标( 坐标的格式(y,x) )
        spawmWay(map[local_map.from_y][local_map.from_x])

最后,我们将这两个方法封装在一起,变成findway()方法
其中,为了防止程序报错,我们先将地图中所有的格子的Iscalled属性初始化,最后我们就有了这个方法

def findWay():
   
    for height in range(1,height_set-1):
        for width in range(1,width_set-1):
            map[height][width].Iscalled = False
    
    print("寻找路径中")
    DoFindway(map[1][1])
    print("路径寻找完毕")

对代码的修修补补

首先先将初始化地图的代码封装在initial()方法里,并添加对墙的初始化.

def initial():
    #初始化地图并记录自身的坐标
    for height in range(0,height_set):
        for width in range(width_set):
            map[height][width] = cube()
            map[height][width].loc_y = height
            map[height][width].loc_x = width

    #初始化起始点
    map[1][0].Iswall = False
    map[1][1].from_x = 0
    map[1][1].from_y = 1

    #=======================初始化边框=========================
    for height in range(0,height_set-1):
         for width in range(width_set-1):
            if(height == 0 or height == width_set-1):
                map[height][width].Iscalled = True
            else:
                map[height][0].Iscalled = True
                map[height][width_set-1].Iscalled = True

在这边,我还添加了两个选项,一个就是要不要生成路径;还有一个是要不要查看迷宫生成的过程
对于生成路径:
如果要生成路径,那么就先将坐标为(1,1)的点设置成路径(因为起点就紧挨着这个路),并且将终点的位置的墙设置成路,将旁边路的属性设置成”终点”

if IsFind =="Y":
    map[1][1].IsWay = True
    map[height_set-2][width_set-1].IsEndpoints = True
    map[height_set-2][width_set-1].Iswall = False
    findWay()

而对于生成迷宫创建的过程,即在每递归一次的时候添加

if Ischeck == "Y":
    printmap()

并且在代码开头添加这两个选项的输入

Ischeck = str(input("是否要查看生成过程(Y/N)"))
IsFind =str(input("是否要寻找路径(Y/N)"))
#=====test=======
if Ischeck !='Y' and Ischeck !='N':
    print("你输入的是:"+Ischeck)
    print("请重新输入Y/N")
    sys.exit()
if IsFind !='Y' and IsFind !='N':
    print("你输入的是:"+IsFind)
    print("请重新输入Y/N")
    sys.exit()

sys.exit()是程序退出的意思

这个结束后就是最后的printmap()方法的修改了,由于我们又添加了路径,又添加了终点,因此要添加对这两个属性的判断:

elif map[height][width].IsWay ==True:
    out = out+". "
elif map[height][width].IsEndpoints ==True:
    out = out+"* "

最后的样子则为:

def printmap():
    out=""
    for height in range(height_set):
        for width in range(width_set):
            if map[height][width].Iswall ==True:
                out = out+"■ "
            elif map[height][width].IsWay ==True:
                out = out+". "
            elif map[height][width].IsEndpoints ==True:
                out = out+"* "
            else:
                out = out +"  "
                
            if width == width_set-1:
                out = out +"\n"
    print(out)

本篇教程就到这里结束了,如果有什么不会的或者是什么可以改进的可以留言,我应该是会及时回复的

改进的那个算法的教程尽量不咕(

ghost_him
关注
专栏目录
深度优先算法走迷宫
ques123456的博客
12-19 748
生成迷宫 大致思路是：首先，生成迷宫全部都是围墙设为1表示围墙的值就是1。其次，把迷宫之外的轮廓设置为0表示边框，然后设置起点和重点的值分别为2和2. 接下来就要在围墙中不断的挖路从而生成迷宫。方法主要是从起点开始每一个上下左右，当发现有路，则往这条路上移动，然后继续判断最终不断递归。 void MAZE::mazeInit()//生成迷宫的主要函数 { //迷宫围墙，nn2+2是规划的迷宫地图大小， 比实际地图要大33 for(int i=0; i<=nn2+2; ++i) for(int j=0;
python寻路_Python迷宫寻路
weixin_39696665的博客
01-29 553
据我所知，你从不检查你是否已经参观过广场。此外，您将使用x和y来表示非x,y坐标的值，并检查索引的一端并捕捉另一端的异常。这太复杂了。我的建议是实现实际的算法：def gen_lee(start, size, travelable):neighbor_offsets = [(0, 1), (1, 0), (0, -1), (-1, 0)]score = 0path_map = [[None for...
基于深度优先算法和广度优先算法的自动寻路迷宫实现
08-16
实现的功能是：随机生成迷宫地图和入口，出口位置，然后利用这两种搜索算法自动走出迷宫。用到的工具是C++的MFC，可以看到运动轨迹。 第一次做C++项目，代码优点乱。可以直接运行My_QQ.sln文件。
深度优先——迷宫算法
forrey的专栏
05-22 1029
   前一阵一直想写这个程序，一直没有有效的解决保存路径的问题。现在想到的办法是用队列保存每个节点的下表来表示路径。 这个算法解决问的问题是： 建一个迷宫（用矩阵表示m行，n列）期中矩阵的左上角（坐标为（0，0的点）为入点，找寻到所有到(m-1,n-1)的所有不重复路径，并打印出来。代码注释如下#include#includeusing namespace std;dequ
python迷宫寻路_迷宫寻路
weixin_39826971的博客
12-08 518
57//AC代码:#include#include#include#includeusing namespace std;char G[105][105];int book[105][105][1200],N,M;int Next[4][2]={0,1,0,-1,1,0,-1,0};int bfs(int,int);struct node{int x,y,k,step;node(int x,int...
Python-用于使用深度优先搜索和递归回溯算法生成和解决随机可解迷宫的Python脚本
08-11
用于使用深度优先搜索和递归回溯算法生成随机可解迷宫的Python脚本。 该代码还实现了用于解决生成的迷宫的递归回溯寻路算法。 这里是一个生成的迷宫及其计算解决方案的例子。
CSP竞赛案例：“迷宫寻路”的Python实现及算法优化方法解析
最新发布
10-09
内容概要：介绍了一个具体的 CSP 比赛案例“迷宫寻路”，详细描述了整个解决问题的方法流程，从问题背景到实现细节进行了详细阐述。具体涉及了基本版本的BFS算法实现代理、进一步进行的空间与时间方面的多项性能优化...
10分钟教你用python动画演示深度优先算法搜寻逃出迷宫的路径
09-18
深度优先搜索（Depth First ...通过本文的讲解，读者应能掌握深度优先搜索算法的应用，并能应用于解决实际问题，如迷宫寻路等。同时，学习如何利用Python将算法实现过程可视化，有助于更好地分析和展示算法的运行效果。
python迷宫寻路_Python3 A*寻路算法实现方式
weixin_39551996的博客
12-08 1700
我就废话不多说了，直接上代码吧！# -*- coding: utf-8 -*-import mathimport randomimport copyimport timeimport sysimport tkinterimport threading# 地图tm = ['############################################################','#...
Python算法-寻址算法
01-11
本主题主要探讨的是Python实现的三种寻址算法：宽度优先搜索（BFS）、深度优先搜索（DFS）以及A*（AStar）算法。这三种算法在解决寻路问题时各有特点，下面将详细介绍它们的原理、实现方式及其应用场景。 一、宽度...
Python程序_利用递归法和pygame实现迷宫寻路的动态展示
07-30
Pospro写的一个Python程序：利用递归法和pygame实现迷宫寻路的动态展示
踢馆朋友圈迷宫挑战——自动寻路（Python实现）
m0_59236127的博客
02-07 2439
背景 我打开手机，发现有人在QQ空间里叫嚣。 看他得意的样子，显然是在家里呆久了，已经忘了天有多高。 预处理 设计一个迷宫自动寻路算法并不难，但是对于当下这个任务而言，第一个棘手的地方在于，如何把这个迷宫变成计算机认识的样子，也就是迷宫图片的矩阵化。 图片的大小是397×390。先把四周的白边裁掉，再把这幅图中的每一个像素二值化，再根据颜色赋值，黑色用0表示，白色用1表示，建立一个0/1矩阵。考虑到迷宫的边界都是封闭的，为了防止由于图片质量问题导致某些看上去是0的地方其实是1，在之后走迷宫的过程中造成一些
算法:(BFS)迷宫寻路算法
长舒的博客
03-21 5733
行远必自迩 登高必自卑 来自蓝桥杯oj 解法 这一题属于典型的迷宫搜索类题，刚入手时我也是一脸茫然，但是仔细思考了一晚上，还是勉强的解决了，这道题属于经典的BFS搜索题，解决的核心在于，如何找到迷宫出口，还有如何存储路径 解法1:BFS+路径存储 作为图论中经典的搜索算法之一，BFS算法搜索路径的特点是"层层搜索"，映射到这个题目上，给我的理解就是，使用BFS这个特点，一旦我们搜索到终点，好吧，...
寻路算法--迷宫寻路
keep moving
08-18 3367
该篇文章接上篇并查集应用——生成随机迷宫, 此时已经可以生成一个任意大小的生成的迷宫        但是看起来还缺点什么，对，就是路径，没有路径怎么证明这真的是个迷宫，因此现学现用把路径加上。首先寻路算法属于图论算法，要想寻路先得有图，什么是图，这个就不细讲了，很多专门讲这个的文章，简单的说图就是一些点再加上连接这些点的边就构成了图，只要把迷宫抽象成图就能应用图论算法了。      .
【游戏编程】AI-迷宫寻路算法-深度优先搜索和广度优先搜索
Health's Box
10-05 2243
状态空间搜索，如果按专业点的说法就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。通俗点说，就是在解一个问题时，找到一条解题的过程可以从求解的开始到问题的结果（好象并不通俗哦）。由于求解问题的过程中分枝有很多，主要是求解过程中求解条件的不确定性，不完备性造成的，使得求解的路径很多这就构成了一个图，我们说这个图就是状态空间。问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。这
深度优先算法--之模拟迷宫
爱敲代码的小鼠的博客
11-24 337
深度优先算法的基本框架： void  DFS(int temp){        临界条件判断//本迷宫临界条件就是迷宫的终点         尝试每一种可能 for(int i=0;i            继续下一步DFS(temp+1);    }    返回 }     public class Algorithm{ //1表示障碍物 ，0表示可走 static in
python迷宫寻路_PTA-迷宫寻路（输出最短路径）
weixin_39628070的博客
12-08 931
给定一个M行N列的迷宫图，其中 "0"表示可通路，"1"表示障碍物，无法通行。在迷宫中只允许在水平或上下四个方向的通路上行走，走过的位置不能重复走。5行8列的迷宫如下：0 1 1 1 0 0 0 00 0 0 1 0 0 0 00 1 0 0 0 1 0 00 1 1 1 0 1 1 01 0 0 0 0 0 0 0则从左上角(1，1)至右下角(5，8)的最短路径为：1,1--》2,1--》2,2...
迷宫寻路三大算法(BFS,DFS,A*)
热门推荐
Dog_dream的博客
05-10 2万+
迷宫寻路 这是我们的数据结构作业本加我们自己再网上找算法记录下来，不过本人比较执着画了几天时间还是把这些算法自己写出来了。总得来说网上所说的大体算法应该就有三种（BFS，DFS，A*） 这里是一个验证网址是南阳OJ的一道题这是网址 http://acm.nyist.me/problem/58 好了不说废话开始吧 BFS 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜...
Python练习(3)——迷宫寻路算法
LEEEEEEY的博客
06-17 3139
Python笔记(5)——迷宫寻路算法 用数组创建出一个迷宫，0为可以通过的路径，1为墙壁。 l = [[0, 0, 1, 1, 1], [1, 0, 1, 1, 1], [0, 0, 1, 0, 0], [0, 1, 1, 0, 1], [0, 0, 0, 0, 1]] for i in l: print(i) 用两个数组记录开始的位置和已走过的位置 stack = [[0, 0]] history = [[0, 0]] 定义上、下、左、右四个函数实现
python迷宫寻路算法
10-15
Python中常用的迷宫寻路算法有很多种，其中比较常见的是深度优先搜索（DFS）、广度优先搜索（BFS）和A*算法。这些算法都可以用来解决迷宫寻路问题，具体选择哪种算法取决于具体情况。 DFS算法是一种基于栈的搜索算法，它从起点开始，沿着某一方向一直走到底，直到无法继续为止，然后回溯到上一个节点，继续探索其他方向。DFS算法的优点是实现简单，但是可能会陷入死循环或者无限递归。 BFS算法是一种基于队列的搜索算法，它从起点开始，先将起点加入队列中，然后依次取出队列中的节点，探索其相邻节点，并将相邻节点加入队列中。BFS算法的优点是能够找到最短路径，但是空间复杂度较高。 A*算法是一种启发式搜索算法，它在BFS算法的基础上加入了估价函数，用来评估每个节点到终点的距离。A*算法的优点是能够找到最优解，并且在空间和时间上都比BFS算法更优秀。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值