迷宫生成算法(Aldous-Broder algorithm)

最新推荐文章于 2021-09-18 15:14:53 发布
最新推荐文章于 2021-09-18 15:14:53 发布
阅读量979 收藏 2
点赞数
分类专栏： 迷宫生成与寻路算法 文章标签： python 迷宫生成算法
除特殊说明外，原创文章禁止转载。原创文章已同步到 https://www.alom.com.cn/。
本文链接：https://blog.csdn.net/defaultbyzt/article/details/115488594
版权

Aldous-Broder算法

算法介绍

英文说明原文

Aldous-Broder algorithm
The Aldous-Broder algorithm also produces uniform spanning trees.

  • 1.Pick a random cell as the current cell and mark it as visited.
  • 2.While there are unvisited cells:
    • 1.Pick a random neighbour.
    • 2.If the chosen neighbour has not been visited:
      • 1.Remove the wall between the current cell and the chosen neighbour.
      • 2.Mark the chosen neighbour as visited.
    • 3.Make the chosen neighbour the current cell.

本人的翻译

Aldous-Broder算法
Aldous-Broder算法也生成统一的生成树。

  • 1。选择一个随机的单元格作为当前单元格，并将其标记为已访问的。
  • 2。当存在未访问细胞时:
    • 1。随机选择一个邻居。
    • 2。如果选中的邻居没有被访问:
      • 1。移除当前单元格和所选邻居之间的墙。
      • 2。标记被选中的邻居已被拜访过。
    • 3。使选择的邻居成为当前单元格。

可以随机移到任务格子，生成迷宫时比较花费时间。

生成的迷宫图

在这里插入图片描述

Python代码

#!/usr/bin/python3.7
# -*- coding: utf-8 -*-
import random
import pygame

#Aldous-Broder algorithm
#The Aldous-Broder algorithm also produces uniform spanning trees.

# 1.Pick a random cell as the current cell and mark it as visited.
# 2.While there are unvisited cells:
#   1.Pick a random neighbour.
#   2.If the chosen neighbour has not been visited:
#       1.Remove the wall between the current cell and the chosen neighbour.
#       2.Mark the chosen neighbour as visited.
#   3.Make the chosen neighbour the current cell.

# Aldous-Broder算法
# Aldous-Broder算法也生成统一的生成树。
# 1。选择一个随机的单元格作为当前单元格，并将其标记为已访问的。
# 2。当存在未访问细胞时:
#   1。随机选择一个邻居。
#   2。如果选中的邻居没有被访问:
#       1。移除当前单元格和所选邻居之间的墙。
#       2。标记被选中的邻居已被拜访过。
#   3。使选择的邻居成为当前单元格。

def aldous_broder_maze(rows, cols):
    # 墙 [0]表示格子访问标记，右[1]竖墙，下[2]横墙
    # (最左和最上墙不能打通，r,c右和r,c+1左共用墙。下墙同理)
    # 初始化未访问，墙未打通
    grids=[[ [0,0,0] for i in range(cols)]for j in range(rows)]
    # Aldous-Broder算法
    # Aldous-Broder算法也生成统一的生成树。
    # 1。选择一个随机的单元格作为当前单元格，并将其标记为已访问的。
    # 2。当存在未访问细胞时:
    #       1。随机选择一个邻居。
    #       2。如果选中的邻居没有被访问:
    #           1。移除当前单元格和所选邻居之间的墙。
    #           2。标记被选中的邻居已被拜访过。
    #       3。使选择的邻居成为当前单元格。

    notusegrids = [] # 没有访问过的格子
    for tr in range(rows):
        for tc in range(cols):
            notusegrids.append((tr,tc))
    # 选择一个随机的单元格作为当前单元格，并将其标记为已访问的。
    r,c = random.choice(notusegrids)
    # 标记迷宫
    grids[r][c][0]=1
    notusegrids.remove((r,c))
    # 当存在未访问细胞时:
    while notusegrids:
        directions = []
        # 可随机方向
        if r > 0:
            directions.append('u')
        if c > 0:
            directions.append('l')
        if r < rows-1:
            directions.append('d')
        if c < cols-1:
            directions.append('r')
        if len(directions):
            # 随机一个方向
            move = random.choice(directions)
            if move == 'u':
                newr = r-1
                newc = c
                nextgrid=(newr, newc)
                opwall=(newr, newc, 2)
            if move == 'l':
                newr = r
                newc = c-1
                nextgrid=(newr, newc)
                opwall=(newr, newc, 1)
            if move == 'd':
                newr = r+1
                newc = c
                nextgrid=(newr, newc)
                opwall=(r, c, 2)
            if move == 'r':
                newr = r
                newc = c+1
                nextgrid=(newr, newc)
                opwall=(r, c, 1)
                
            # 如果选中的邻居没有被访问:
            if grids[newr][newc][0] == 0:
                #   1。移除当前单元格和所选邻居之间的墙。
                #   2。标记被选中的邻居已被拜访过。
                #   3。使选择的邻居成为当前单元格。
                grids[newr][newc][0]=1
                notusegrids.remove((newr,newc))
                grids[opwall[0]][opwall[1]][opwall[2]] = 1
                r=newr
                c=newc   
            else:
                # 使选择的邻居成为当前单元格。
                r=newr
                c=newc 

    return grids


    
# main
if __name__ == "__main__":
    '''main'''
    aldous_broder_maze(20, 30)

演示代码

#!/usr/bin/python3.7
# -*- coding: utf-8 -*-
import random
import pygame
#Aldous-Broder algorithm
#The Aldous-Broder algorithm also produces uniform spanning trees.

# 1.Pick a random cell as the current cell and mark it as visited.
# 2.While there are unvisited cells:
#   1.Pick a random neighbour.
#   2.If the chosen neighbour has not been visited:
#       1.Remove the wall between the current cell and the chosen neighbour.
#       2.Mark the chosen neighbour as visited.
#   3.Make the chosen neighbour the current cell.

# Aldous-Broder算法
# Aldous-Broder算法也生成统一的生成树。
# 1。选择一个随机的单元格作为当前单元格，并将其标记为已访问的。
# 2。当存在未访问细胞时:
#   1。随机选择一个邻居。
#   2。如果选中的邻居没有被访问:
#       1。移除当前单元格和所选邻居之间的墙。
#       2。标记被选中的邻居已被拜访过。
#   3。使选择的邻居成为当前单元格。

# pygame
pygame.init()  # 初始化pygame
size = width, height = 800, 600  # 设置窗口大小
screen = pygame.display.set_mode(size)  # 显示窗口
# 颜色
diamond_color_size = 8
COLOR_RED, COLOR_BLUE, COLOR_GREEN, COLOR_YELLOW, COLOR_BLACK, COLOR_GREY, COLOR_GOLDEN, COLOR_NO_DIAMOND = list(range(
    diamond_color_size))
COLOR = {
    COLOR_RED: (255, 0, 0),
    COLOR_BLUE: (0, 0, 255),
    COLOR_GREEN: (0, 255, 0),
    COLOR_YELLOW: (255, 255, 0),
    COLOR_BLACK: (0, 0, 0),
    COLOR_GREY: (250, 240, 230),
    COLOR_GOLDEN : (255,215,0),
    COLOR_NO_DIAMOND: (100, 100, 100),
}
# 格子大小
DIAMOND_SIZE = (20, 20)
# 蓝格子
DIAMOND=pygame.surface.Surface(DIAMOND_SIZE).convert()
DIAMOND.fill(COLOR[COLOR_BLUE])
# 绿格子 
DIAMOND_GREEN=pygame.surface.Surface(DIAMOND_SIZE).convert()
DIAMOND_GREEN.fill(COLOR[COLOR_GREEN])
# 红格子 
DIAMOND_RED=pygame.surface.Surface(DIAMOND_SIZE).convert()
DIAMOND_RED.fill(COLOR[COLOR_RED])
# 黄格子 
DIAMOND_YELLOW=pygame.surface.Surface(DIAMOND_SIZE).convert()
DIAMOND_YELLOW.fill(COLOR[COLOR_YELLOW])
# 灰的格子 
DIAMOND_GREY=pygame.surface.Surface(DIAMOND_SIZE).convert()
DIAMOND_GREY.fill(COLOR[COLOR_GREY])

# 字体
use_font = pygame.font.Font("FONT.TTF", 16)
# 行列
num_cols=30 #
num_rows=20 #
# 背景
background=pygame.surface.Surface(((num_cols ) * DIAMOND_SIZE[0] + 2 , (num_rows ) * DIAMOND_SIZE[1] + 2)).convert()
background.fill(COLOR[COLOR_BLUE])
# 时间
clock = pygame.time.Clock()

##############################################
#   格子访问标记x,y,0，右墙x,y,1，下墙x,y,2
##############################################


# 
def add2maze(grids, notusegrids, tgrids, twalls):
    for (r,c) in tgrids:
        notusegrids.remove((r,c))
        grids[r][c][0]=1
    for (r,c,x) in twalls:
        grids[r][c][x]=1 
    return 

# 随机格子
def aldous_broder_maze_demo(rows, cols):
        # 墙 [0]表示格子访问标记，右[1]竖墙，下[2]横墙
    # (最左和最上墙不能打通，r,c右和r,c+1左共用墙。下墙同理)
    # 初始化未访问，墙未打通
    grids=[[ [0,0,0] for i in range(cols)]for j in range(rows)]
    # Aldous-Broder算法
    # Aldous-Broder算法也生成统一的生成树。
    # 1。选择一个随机的单元格作为当前单元格，并将其标记为已访问的。
    # 2。当存在未访问细胞时:
    #       1。随机选择一个邻居。
    #       2。如果选中的邻居没有被访问:
    #           1。移除当前单元格和所选邻居之间的墙。
    #           2。标记被选中的邻居已被拜访过。
    #           3。使选择的邻居成为当前单元格。

    notusegrids = [] # 没有访问过的格子
    for tr in range(rows):
        for tc in range(cols):
            notusegrids.append((tr,tc))
    # 选择一个随机的单元格作为当前单元格，并将其标记为已访问的。
    r,c = random.choice(notusegrids)
    # 标记迷宫
    grids[r][c][0]=1
    notusegrids.remove((r,c))
    
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return
        # 当存在未访问细胞时:
        if  notusegrids:
            directions = []
            # 可随机方向
            if r > 0:
                directions.append('u')
            if c > 0:
                directions.append('l')
            if r < rows-1:
                directions.append('d')
            if c < cols-1:
                directions.append('r')
            if len(directions):
                # 随机一个方向
                move = random.choice(directions)
                if move == 'u':
                    newr = r-1
                    newc = c
                    nextgrid=(newr, newc)
                    opwall=(newr, newc, 2)
                if move == 'l':
                    newr = r
                    newc = c-1
                    nextgrid=(newr, newc)
                    opwall=(newr, newc, 1)
                if move == 'd':
                    newr = r+1
                    newc = c
                    nextgrid=(newr, newc)
                    opwall=(r, c, 2)
                if move == 'r':
                    newr = r
                    newc = c+1
                    nextgrid=(newr, newc)
                    opwall=(r, c, 1)
                    
                # 如果选中的邻居没有被访问:
                if grids[newr][newc][0] == 0:
                    #   1。移除当前单元格和所选邻居之间的墙。
                    #   2。标记被选中的邻居已被拜访过。
                    #   3。使选择的邻居成为当前单元格。
                    grids[newr][newc][0]=1
                    notusegrids.remove((newr,newc))
                    grids[opwall[0]][opwall[1]][opwall[2]] = 1
                    r=newr
                    c=newc   
                else:
                    # 使选择的邻居成为当前单元格。
                    r=newr
                    c=newc 

        screen.blit(background, (0, 0))
        # 格子
        for cx in range(num_cols):
            for ry in range(num_rows):
                px,py=1 + (cx) * DIAMOND_SIZE[0], 1 + (ry) * DIAMOND_SIZE[1]
                # 标记访问过的格子
                if grids[ry][cx][0]:
                    screen.blit(DIAMOND, (px, py))
                else:
                    screen.blit(DIAMOND_GREY, (px, py))
        if notusegrids:
            px,py=1 + (c) * DIAMOND_SIZE[0], 1 + (r) * DIAMOND_SIZE[1]
            screen.blit(DIAMOND_GREEN, (px, py))

        # 画外墙
        pygame.draw.rect(screen, COLOR[COLOR_RED], (0, 0, 20*num_cols+1, 20*num_rows+1), 2)
        # 画没打通的墙
        for cx in range( num_cols):
            for ry in range(num_rows):
                px,py=21 + (cx) * DIAMOND_SIZE[0], 21 + (ry) * DIAMOND_SIZE[1]
                color = COLOR[COLOR_BLACK]
                if not grids[ry][cx][1]:
                    pygame.draw.line(screen, color, (px, py-20), (px, py), 2)
                if not grids[ry][cx][2]:
                    pygame.draw.line(screen, color, (px-20, py), (px, py), 2)

        # 
        if not notusegrids:
            score_surface = use_font.render("生成完成！", True, COLOR[COLOR_BLACK], COLOR[COLOR_GREY])
            screen.blit(score_surface, (50, num_rows*22))
        
        time_passed = clock.tick(30)

        pygame.display.update()
    return 



# main
if __name__ == "__main__":
    '''main'''
    aldous_broder_maze_demo(20, 30)

GIF演示

在这里插入图片描述

参考

https://en.wikipedia.org/wiki/Maze_generation_algorithm#Randomized_depth-first_search

http://weblog.jamisbuck.org/2011/1/17/maze-generation-aldous-broder-algorithm

访问时可能需要梯子

上一篇：迷宫生成算法(Wilson‘s algorithm)

迷宫生成算法(Wilson‘s algorithm)

火苗999℃
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MazeGenerator:使用深度优先搜索算法生成迷宫
04-13
迷宫发电机 使用深度优先搜索算法生成迷宫
矩阵迷宫（A*）
11-16
Android 01矩阵迷宫，网上找了好久才找到的资源，使用A*算法，感觉不错
迷宫生成算法(Wilson‘s algorithm)
火苗999℃的博客
04-07 1284
Wilson算法算法介绍英文说明原文本人的翻译生成的迷宫图Python代码演示代码GIF演示参考 算法介绍 英文说明原文 We begin the algorithm by initializing the maze with one cell chosen arbitrarily. Then we start at a new cell chosen arbitrarily, and perform a random walk until we reach a cell already in the ma
cocos creator 2.x 地牢迷宫生成器
xuzhaojia的专栏
07-20 670
先上图： 在线演示地址 [地址]：地牢迷宫生成器 商店地址 [cocos商店] :地牢迷宫生成器_MazeGenerator 简介 地牢迷宫和普通的迷宫有所不同，一个最基本地牢迷宫是由很多的房间和联通房间的路径组成的。其余都是围墙，即不可到达的区域。玩家从一个入口进入，沿着弯弯曲曲的路径，经过不同房间最终到达出口（或者其他玩法）。 白色方块代表房间和路径 黑色方块代表不可到达区域 带棕色横条的方块代表门 算法 所见即算法： 生成所有房间 生成迷宫路径 联通所有房间和路径...
游戏常用算法：四种迷宫生成算法
august5291的博客
09-18 9039
https://www.fgba.net/sitemap.xml
Maze-generation-algorithm:视觉表示的迷宫生成算法的实现
04-15
总结来说，"Maze-generation-algorithm"项目提供了一种在Python中实现迷宫生成算法的途径，结合视觉表示，使得迷宫的创建和理解变得更加直观和有趣。通过深入研究该项目，我们可以学习到不同类型的迷宫生成算法以及...
MazeGenerator:生成迷宫的算法的集合
04-22
Aldous-Broder算法--ab 维基百科代码 递归除法--div 维基百科代码 用法 USAGE: maze_generator [FLAGS] [OPTIONS] FLAGS: --dfs Use the depth first search algorithm for maze generation [default] --tree...
java-maze-algorithms:Java中的迷宫生成和求解算法
05-10
生成算法阿尔杜斯·布罗德（Aldous-Broder） 二叉树深度优先搜索（递归回溯） 埃勒的越来越多的森林越来越多的树猎杀休斯顿克鲁斯卡尔的普里姆斯四深度优先搜索响尾蛇螺旋回溯器威尔逊的之字形求解算法广度优先搜索...
MazeGenerator
04-03
应用Aldous-Border算法生成迷宫。 使用A *算法或其他路径查找。 对于A *，我们可以通过实现min-heap或优先级队列来存储访问的邻居来对其进行优化，并在获取最低f得分值的同时获得O（1）的时间复杂度。创建矩阵产生...
C#实现4种经典迷宫生成算法和迷宫寻路算法
12-05
C#实现4种经典迷宫生成算法和迷宫寻路算法，4种经典的迷宫生成算法是：（1）使用并查集算法生成，（2）使用深度优先算法生成，（3）使用随机算法生成，（4）使用递归切割算法，而迷宫寻路使用A*算法。
迷宫发生器
02-08
迷宫发生器
MazeGenerator:JavaScript中的随机迷宫生成器
05-10
迷宫发电机 JavaScript中的随机迷宫生成器 在这里进行测试： :
C#写的表达式计算和迷宫求解源代码
07-02
用vs 2005写的表达式计算和迷宫求解小程序，有需要写作业的同学可以下载，不过需要肉痛点，给3分就好。。。。。 注：迷宫只有求解算法，没有绘图功能，所以不是迷宫游戏。
迷宫生成器：使用图论生成不同形状和任意大小的迷宫
02-28
迷宫发电机 生成不同形状和任意大小的迷宫 迷宫发生器可以产生矩形，六角形，蜂窝和圆形迷宫。 迷宫生成可以使用Kruskal算法，深度优先搜索，广度优先搜索，循环擦除的随机游走或Prim算法来完成。 迷宫可以svg或png格式渲染（在后一种情况下，使用gnuplot作为中间对象）。 依存关系 迷宫生成器使用gnuplot（系统调用gnuplot ）来渲染png迷宫。 因此，如果要使用png，请确保gnuplot 5.0+已安装了pngcairo终端支持，并且位于路径中。 该代码是用C ++ 11编写的，您将需要一个不太古老的C ++编译器来构建它。 安装 cd src; make 用法 Usage: mazegen [--help] [-m <maze>] [-a <algorithm>] [-s <size> | -w <width>
迷宫生成算法
leon90dm的专栏
10-16 1743
摘要  　　本文对随机迷宫生成进行了初步的研究和分析，并给出了两种不同的生成算法。最终的算法结合了图的深度优先遍历。通过对比两种算法之间，可发现，在实际问题中，结合了离散数学的方法往往非更有效率且效果更佳。  　　关键词：随机地图生成(random maze generating)、深度优先遍历(depth-first search)  1. 引言  　　在平常的游戏中，我
C#实现4种经典迷宫生成算法和迷宫寻路算法（一）
lweiyue的专栏
12-05 4295
4种经典的迷宫生成算法是： （1）使用并查集算法生成 （2）使用深度优先算法生成 （3）使用随机算法生成 （4）使用递归切割算法 而迷宫寻路使用A*算法。 我把所有迷宫生成定义成一个虚类，每一种生成算法是继承虚类的一个实现。当然，寻路算法也在虚类中，因为无论迷宫如何生成，寻路算法都是一样的。为了阅读的流畅性，在下面的代码中，暂不包含寻路算法。 /// &lt;summary&gt;...
C#三大迷宫生成算法
热门推荐
dark00800的专栏
07-30 1万+
今天介绍一下很经典的三大迷宫算法的C#实现，即随机普利姆算法，深度优先算法和十字分割（也就是递归分割算法）。实现参考了[ActionScript 3] 三大迷宫生成算法一文（生成的迷宫预览图也使用的该文中的示意图），并且讲三种方法进行分装，方便游戏调用。1、设计基类Maze类为了方便我们游戏逻辑去调用三种迷宫算法，我们设计一个基类供继承，基类是一个抽象类，其中包括一些迷宫地图的必要属性和生成迷宫的抽
C#迷宫生成的算法，供参考
07-04
C#迷宫生成的算法，供参考
把字符串'aldous Huxley was born in 1894.'的第一个字母大写
最新发布
06-04
您可以使用 Python 内置的字符串方法 `capitalize()` 来将字符串的第一个字母大写，代码如下： ```python s = 'aldous Huxley was born in 1894.' s = s.capitalize() print(s) ``` 输出结果为： ``` Aldous huxley was born in 1894. ``` 需要注意的是，该方法会将字符串中的其他字母全部转为小写。如果您不想改变其他字母的大小写，可以使用字符串切片和拼接的方法，代码如下： ```python s = 'aldous Huxley was born in 1894.' s = s[0].upper() + s[1:] print(s) ``` 输出结果为： ``` Aldous Huxley was born in 1894. ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值