迷宫生成算法(Randomized Prim‘s algorithm)

最新推荐文章于 2023-11-13 09:07:13 发布
最新推荐文章于 2023-11-13 09:07:13 发布
阅读量654 收藏 3
点赞数
分类专栏： 迷宫生成与寻路算法
除特殊说明外，原创文章禁止转载。原创文章已同步到 https://www.alom.com.cn/。
本文链接：https://blog.csdn.net/defaultbyzt/article/details/115400933
版权

随机普里姆算法 迷宫生成 Python代码 动画演示 数据结构
关键词由CSDN通过智能技术生成

随机普里姆算法

随机普里姆算法介绍

  • 1。从布满墙壁的网格开始。
  • 2。选一个细胞，把它标记为迷宫的一部分。将单元格的墙添加到墙列表中。
  • 3。名单上有墙:
    • 1。从列表中随机选择一面墙。如果墙壁分开的两个单元格中只有一个被访问，那么:
      • 1。将墙壁做成通道，并将未造访的单元格标记为迷宫的一部分。
      • 2。将单元格相邻的墙添加到墙列表中。
    • 2。把墙从列表中移除。

生成的迷宫偏向于多支路的短的死胡同。

代码

Python代码：

#!/usr/bin/python3.7
# -*- coding: utf-8 -*-
import random
# Randomized Prim's algorithm
#1.Start with a grid full of walls.
#2.Pick a cell, mark it as part of the maze. Add the walls of the cell to the wall list.
#3.While there are walls in the list:
#	1.Pick a random wall from the list. If only one of the two cells that the wall divides is visited, then:
#		1.Make the wall a passage and mark the unvisited cell as part of the maze.
#		2.Add the neighboring walls of the cell to the wall list.
#	2.Remove the wall from the list.
# 随机普里姆算法
# 1。从布满墙壁的网格开始。
# 2。选一个细胞，把它标记为迷宫的一部分。将单元格的墙添加到墙列表中。
# 3。名单上有墙:
#   1。从列表中随机选择一面墙。如果细胞壁分裂的两个细胞中只有一个被访问，那么:
#       1。将墙壁做成通道，并将未造访的牢房标记为迷宫的一部分。
#       2。将单元格相邻的墙添加到墙列表中。
# 2。把墙从列表中移除。

# 随机墙
# prim算法
def prim_maze(rows, cols):
    num_cols=cols
    num_rows=rows
    # 墙 0表示通路 |竖墙 -横墙
    wall=[[ ['|','-'] for i in range(num_cols+1)]for i in range(num_rows+1)]
    # 已访问标记
    way=[[ 0 for i in range(num_cols)]for i in range(num_rows)]
    # 设置起点
    r=0
    c=0
    # 起点加入记录
    # 标记为迷宫的一部分
    way[r][c]=1
    # 墙列表
    walllist=[]
    walllist.append((r+1,c,'-'))
    walllist.append((r,c+1,'|'))
    # 
    while walllist:
        # 随机选一个墙
        r, c, d = random.choice(walllist)
        # 移除墙
        walllist.remove((r,c,d))
        if d == '|':
            # 如果这面墙分隔的两个单元格只有一个单元格被访问过，那么：
            if c > 0 and (not way[r][c-1] == way[r][c] ):
                #1.把墙打通，将未访问的单元格标记成为迷宫的一部分
                wall[r][c][0]=0
                if way[r][c] == 1:
                    nc=c-1
                else:
                    nc=c
                c=nc
                way[r][c]=1
                #2.将单元格相邻的墙加入到墙列表中
                # 上
                if r > 0 and wall[r][c][1] == '-':
                    walllist.append((r,c,'-'))
                # 下
                if r+1 < num_rows and wall[r+1][c][1] == '-':
                    walllist.append((r+1,c,'-'))
                # 左
                if c > 0 and wall[r][c][0] == '|':
                    walllist.append((r,c,'|'))
                # 右
                if c+1 < num_cols and wall[r][c+1][0] == '|':
                    walllist.append((r,c+1,'|'))
        elif d == '-':
            # 如果这面墙分隔的两个单元格只有一个单元格被访问过，那么：
            if r > 0 and ( (not way[r-1][c]) == way[r][c] ):
                #1.把墙打通，将未访问的单元格标记成为迷宫的一部分
                wall[r][c][1]=0
                if way[r][c] == 1:
                    nr=r-1
                else:
                    nr=r
                r=nr
                way[r][c]=1
                #2.将单元格相邻的墙加入到墙列表中
                # 上
                if r > 0 and wall[r][c][1] == '-':
                    walllist.append((r,c,'-'))
                # 下
                if r + 1 < num_rows and wall[r+1][c][1] == '-':
                    walllist.append((r+1,c,'-'))
                # 左
                if c > 0 and wall[r][c][0] == '|':
                    walllist.append((r,c,'|'))
                # 右
                if c + 1 < num_cols and wall[r][c+1][0] == '|':
                    walllist.append((r,c+1,'|'))
        #2.如果墙两面的单元格都已经被访问过，那就从列表里移除这面墙
        for rrr1, ccc1, ddd1 in walllist:
            if ddd1 == '|':
                if ccc1 > 0 and way[rrr1][ccc1-1] == 1 and way[rrr1][ccc1] == 1:
                    walllist.remove((rrr1,ccc1,ddd1))
            elif ddd1 == '-':
                if rrr1 > 0 and way[rrr1-1][ccc1] == 1 and way[rrr1][ccc1] == 1:
                    walllist.remove((rrr1,ccc1,ddd1))
    return wall

动画演示代码

#!/usr/bin/python3.7
# -*- coding: utf-8 -*-
import random
import pygame
# Randomized Prim's algorithm
# Randomized Prim's algorithm
#1.Start with a grid full of walls.
#2.Pick a cell, mark it as part of the maze. Add the walls of the cell to the wall list.
#3.While there are walls in the list:
#	1.Pick a random wall from the list. If only one of the two cells that the wall divides is visited, then:
#		1.Make the wall a passage and mark the unvisited cell as part of the maze.
#		2.Add the neighboring walls of the cell to the wall list.
#	2.Remove the wall from the list.
# 随机普里姆算法
# 1。从布满墙壁的网格开始。
# 2。选一个细胞，把它标记为迷宫的一部分。将单元格的墙添加到墙列表中。
# 3。名单上有墙:
#   1。从列表中随机选择一面墙。如果细胞壁分裂的两个细胞中只有一个被访问，那么:
#       1。将墙壁做成通道，并将未造访的牢房标记为迷宫的一部分。
#       2。将单元格相邻的墙添加到墙列表中。
# 2。把墙从列表中移除。
# pygame
pygame.init()  # 初始化pygame
size = width, height = 800, 600  # 设置窗口大小
screen = pygame.display.set_mode(size)  # 显示窗口
# 行列
num_cols=30 #
num_rows=20 #

# 墙 0表示通路 |竖墙 -横墙
wall=[[ ['|','-'] for i in range(num_cols+1)]for i in range(num_rows+1)]

# 已访问标记
way=[[ 0 for i in range(num_cols)]for i in range(num_rows)]
# 颜色
diamond_color_size = 7
COLOR_RED, COLOR_BLUE, COLOR_GREEN, COLOR_YELLOW, COLOR_BLACK, COLOR_GREY, 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_NO_DIAMOND: (100, 100, 100),
}
# 格子大小
DIAMOND_SIZE = (20, 20)
# 格子
DIAMOND=pygame.surface.Surface(DIAMOND_SIZE).convert()
DIAMOND.fill(COLOR[1])

# 绿格子 
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])

def draw_grid(lw, surface, rgb_color):
    rect = (lw, lw, DIAMOND_SIZE[0] -2*lw, DIAMOND_SIZE[1] -2*lw)
    pygame.draw.line(surface, rgb_color, (rect[0], rect[1]), (rect[0], rect[3]), lw)
    pygame.draw.line(surface, rgb_color, (rect[0], rect[1]), (rect[2], rect[1]), lw)
    pygame.draw.line(surface, rgb_color, (rect[0], rect[3]), (rect[2], rect[3]), lw)
    pygame.draw.line(surface, rgb_color, (rect[2], rect[1]), (rect[2], rect[3]), lw)
    return

def draw_wall(lw, surface, rgb_color):
    rect = (lw, lw, DIAMOND_SIZE[0] -2*lw, DIAMOND_SIZE[1] -2*lw)
    # 左
    pygame.draw.line(surface, rgb_color, (rect[0], rect[1]), (rect[0], rect[3]), lw)
    # 上
    pygame.draw.line(surface, rgb_color, (rect[0], rect[1]), (rect[2], rect[1]), lw)
    # 下
    pygame.draw.line(surface, rgb_color, (rect[0], rect[3]), (rect[2], rect[3]), lw)
    # 右
    pygame.draw.line(surface, rgb_color, (rect[2], rect[1]), (rect[2], rect[3]), lw)
    return
# 字体
use_font = pygame.font.Font("FONT.TTF", 16)
#draw_grid(2, DIAMOND, (128, 128, 128))
# 背景
background=pygame.surface.Surface(((num_cols ) * DIAMOND_SIZE[0] + 2 , (num_rows ) * DIAMOND_SIZE[1] + 2)).convert()
background.fill(COLOR[2])

# 时间
clock = pygame.time.Clock()


# 随机墙
def prim_maze_demo():
    global way
    global wall
    # 设置起点
    r=0
    c=0
    # 起点加入记录
    # 标记为迷宫的一部分
    way[r][c]=1
    # 墙列表
    walllist=[]
    walllist.append((r+1,c,'-'))
    walllist.append((r,c+1,'|'))

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return

        if walllist:
            # 随机选一个墙
            r, c, d = random.choice(walllist)
            rr,cc,dd=r,c,d
            # 移除墙
            walllist.remove((r,c,d))
            if d == '|':
                # 如果这面墙分隔的两个单元格只有一个单元格被访问过，那么：
                if c > 0 and (not way[r][c-1] == way[r][c] ):
                    #1.把墙打通，将未访问的单元格标记成为迷宫的一部分
                    wall[r][c][0]=0
                    if way[r][c] == 1:
                        nc=c-1
                    else:
                        nc=c
                    c=nc
                    way[r][c]=1
                    #2.将单元格相邻的墙加入到墙列表中
                    # 上
                    if r > 0 and wall[r][c][1] == '-':
                        walllist.append((r,c,'-'))
                    # 下
                    if r+1 < num_rows and wall[r+1][c][1] == '-':
                        walllist.append((r+1,c,'-'))
                    # 左
                    if c > 0 and wall[r][c][0] == '|':
                        walllist.append((r,c,'|'))
                    # 右
                    if c+1 < num_cols and wall[r][c+1][0] == '|':
                        walllist.append((r,c+1,'|'))
            elif d == '-':
                # 如果这面墙分隔的两个单元格只有一个单元格被访问过，那么：
                if r > 0 and ( (not way[r-1][c]) == way[r][c] ):
                    #1.把墙打通，将未访问的单元格标记成为迷宫的一部分
                    wall[r][c][1]=0
                    if way[r][c] == 1:
                        nr=r-1
                    else:
                        nr=r
                    r=nr
                    way[r][c]=1
                    #2.将单元格相邻的墙加入到墙列表中
                    # 上
                    if r > 0 and wall[r][c][1] == '-':
                        walllist.append((r,c,'-'))
                    # 下
                    if r + 1 < num_rows and wall[r+1][c][1] == '-':
                        walllist.append((r+1,c,'-'))
                    # 左
                    if c > 0 and wall[r][c][0] == '|':
                        walllist.append((r,c,'|'))
                    # 右
                    if c + 1 < num_cols and wall[r][c+1][0] == '|':
                        walllist.append((r,c+1,'|'))
            #2.如果墙两面的单元格都已经被访问过，那就从列表里移除这面墙
            for rrr1, ccc1, ddd1 in walllist:
                if ddd1 == '|':
                    if ccc1 > 0 and way[rrr1][ccc1-1] == 1 and way[rrr1][ccc1] == 1:
                        walllist.remove((rrr1,ccc1,ddd1))
                elif ddd1 == '-':
                    if rrr1 > 0 and way[rrr1-1][ccc1] == 1 and way[rrr1][ccc1] == 1:
                        walllist.remove((rrr1,ccc1,ddd1))

        screen.blit(background, (0, 0))
        # 画格子
        for x in range(num_cols):
            for y in range(num_rows):
                px,py=1 + (x) * DIAMOND_SIZE[0], 1 + (y) * DIAMOND_SIZE[1]
                # 标记走过的
                if way[y][x]:
                    screen.blit(DIAMOND, (px, py))
                else:
                    screen.blit(DIAMOND_GREY, (px, py))

        # 画外墙
        pygame.draw.rect(screen, COLOR[COLOR_RED], (0, 0, 20*num_cols+1, 20*num_rows+1), 2)
        # 画没打通的墙
        for x in range( num_cols):
            for y in range(num_rows):
                px,py=1 + (x) * DIAMOND_SIZE[0], 1 + (y) * DIAMOND_SIZE[1]
                color = COLOR[COLOR_BLACK]
                if wall[y][x][0]:
                    pygame.draw.line(screen, color, (px, py), (px, py+20), 2)
                if wall[y][x][1]:
                    pygame.draw.line(screen, color, (px, py), (px+20, py), 2)
        
        # 画记录列表里的墙记
        for rrr,ccc,ddd in walllist:
            px,py=1 + (ccc) * DIAMOND_SIZE[0], 1 + (rrr) * DIAMOND_SIZE[1]
            color = (255,50,255)
            if ddd == '|':
                pygame.draw.line(screen, color, (px, py), (px, py+20), 2)
            else:
                pygame.draw.line(screen, color, (px, py), (px+20, py), 2)
        # 画刚被打通的墙
        if walllist:
            px,py=1 + (cc) * DIAMOND_SIZE[0], 1 + (rr) * DIAMOND_SIZE[1]
            color = (255,215,0)
            if dd == '|':
                pygame.draw.line(screen, color, (px, py), (px, py+20), 2)
            else:
                pygame.draw.line(screen, color, (px, py), (px+20, py), 2)
        # 
        if not walllist:
            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'''
    prim_maze_demo()

gif动画

在这里插入图片描述

参考：

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

上一篇：迷宫生成算法(Randomized depth-first search)

迷宫生成算法(Randomized depth-first search)

下一篇：迷宫生成算法(Randomized Kruskal‘s algorithm)

迷宫生成算法(Randomized Kruskal‘s algorithm)

张拓1070410059
关注
专栏目录
生成迷宫算法
不知博者的博客
05-13 556
这个算法还是从网上找的，本来想用excle表格导出一个由1和0组成的迷宫，但是我用记事本将换行符换掉以后，发现顺序就乱了，可能是因为excle导出的文本里面含有其他字符，这种方法目前我还没有解决。所以就用了网上的方法。我下面介绍的是最简单，并且粗浅的生成迷宫的方法。网上有很多特别好而且特别细致的算法： 这里是资源http://www.doc88.com/p-5187301484773.html 向
迷宫生成算法
jjwwwww的博客
06-07 5506
迷宫生成算法随便聊点设计思路代码实现 随便聊点 关于迷宫算法其实我之前写过两篇文章，不过这两天突然需要用到了，看了两分钟自己的博客居然一时没怎么看懂。不过毕竟我之前研究过，花了点时间还是给重新写了出来，相比之下反而觉得以前写的代码有点累赘了，鉴于之前那篇文章点击率也蛮高的，删掉重写又怪可惜的，想想就顺便再水一篇吧。 设计思路 先来张效果图： 我们可以把迷宫建立的过程想象成挖地道。首先，假设我们当前所在位置是(x,y)，此时我们可以挖的方向分别是上下左右四个方向： 上(x-1,
生成迷宫的算法
weixin_33935777的博客
08-13 69
2019独角兽企业重金招聘Python工程师标准>>> ...
三大迷宫生成算法 (Maze generation algorithm) -- 深度优先，随机Prim，递归分割
热门推荐
Much effort, much prosperity.
06-12 7万+
之前同学参加面试，面试官问到迷宫生成算法，这个问题自己想了下也没有好办法，所有就查询了相关资料。这里进行了相关整理： 本文主要讲解的迷宫生成算法有三种： 1.Recursive backtracker ( 递归回溯，也是深度优先算法） 2.Randomized Prim's algorithm（随机Prim算法，让我想起了最小生成树的Prim算法） 3.Recursive division
Pathfinding-Visualizer:可视化五种寻路算法和迷宫生成算法
05-09
路径查找和迷宫生成算法可视化工具 内置VanillaJs，HTML和CSS 该应用程序将五种不同的寻路算法和五种迷宫生成算法可视化。 您可以一次可视化一个算法，也可以同时可视化多个算法。 最多有四个网格可用，在每个网格...
Java深度优先遍历算法随机生成迷宫
peanuo的博客
12-15 2380
头一次写CSDN，刚好最近在做Java有关的实验，于是顺便发一篇，水平不够，有错见谅。
[Algorithm]Maze Prim算法与A*寻路算法（中）
星空不语
02-06 1229
附上全文连接： [Algorithm]Maze Prim算法与A*寻路算法（上） [Algorithm]Maze Prim算法与A*寻路算法（中） [Algorithm]Maze Prim算法与A*寻路算法（下）文章中的所有源码下载链接附在“[Algorithm]Maze Prim算法与A*寻路算法（上） ”文章中。上一篇中大致讲了下内容，接下来将要讲的是Maze Prim算法。 先附上一段
Unity大型场景程序化生成及优化技术—FPS迷宫生成和优化
manmanshou的博客
03-06 1859
Unity大型场景程序化生成及优化技术—FPS迷宫生成和优化 1、知名游戏中的大型场景生成 场景程序化生成技术是一个广泛应用在游戏开发中的技术，较早的使用这类技术有名游戏《暗黑破坏神》系列，无论是1代、2代、3代，都使用了这个技术，如下图1-1：每次进入野外场景的时候能看到随机的场景（随机地形、随机怪物、随机藏宝点） 图1-1 《暗黑破坏神3》随机地下城 另外一个知名游戏是手游《列王的纷争（CO...
primmatlab代码-Randomized_Prim_Algorithm_Experiment:Randomized_Prim_Algor
06-07
prim matlab代码Randomized_Prim_Algorithm_Experiment 项目名称：实验对象提案的随机Prim算法参考论文： 源代码： 报告： 总结：这个项目是 Mitchell 教授研究项目的一部分，它是为了实证研究对象建议方法如何有效地达到完成的遛狗情况。 完成的遛狗情况代表了遛狗的人，狗和皮带应该通过机器学习算法找到。 对象提议的思想是算法为给定图像的任何可能对象生成多个边界框。 职责： 阅读一篇关于利用对象提议算法（随机 Prim 算法）完成遛狗任务的研究论文，了解已完成遛狗的给定定义。 在 MATLAB 中编写实验脚本来运行对象建议算法，以评估随机 Prim 算法在遛狗任务中的准确度。 为研究项目写了总结报告。
迷宫生成算法和迷宫寻径算法
09-14
本源码通过C# GDI+ 编写。提供三种生成迷宫的算法（深度优先法，递归分割法，随机PRIM法），提供基于广度优先算法的迷宫自动寻径算法。迷宫大小、单元格大小、线粗均可自定义。优化了算法，递归改为栈实现，能够生成任意大地图而不会引起原来的函数递归栈溢出问题。生成迷宫后，支持键盘按键进行手动走迷宫。
随机迷宫生成算法（一）（C++）
nanfang0的博客
12-25 6019
迷宫生成算法可以形象的理解数据结构中图的相关知识，标准二维迷宫中，每一个方块都可以抽象为图的一个顶点，而且这个图是一个无向图，且权为一，实际写起来也没有那样复杂。 迷宫生成算法大体可分为四种，深度优先算法，最小生成树算法中的Prim算法和Kruskal算法，递归分割算法。 由于本人也是初学者，只能边学边练，写文章以作巩固和复习使用。 本算法图像的输出使用easyX图形库。
迷宫随机生成算法
twopointfive的专栏
03-23 5577
迷宫随机生成算法
迷宫生成算法总结
哆啦A瑶的博客
01-31 5465
最近闲来无事想做一个质量高一点的进阶版的迷宫小游戏，首先就要先生成最基础的迷宫地图，因此学习并整理了一下迷宫生成算法。由于python更容易实现这些算法，因此首先使用pyhon将各种生成算法整理一遍，之后再用Qt或者javascript重写一遍，再加上可视化。 大概了解了一下，生成迷宫的算法主要有三种思路，其中最小生成树算法又可以分为选点法（prim）和选边法（kruskal）： 随机深度优先算...
三种迷宫生成算法
zczxczc的专栏
01-07 3045
Recursive backtracking 生成迷宫路线单一，需要添加随机打墙的功能，增加迷宫的复杂度 public static void maze() { char block = 'x'; char way = ' '; int size = 100; char[][] maze = new char[size * 2 - 1][size * 2 - 1];
有关迷宫的生成算法和解密算法
最新发布
weixin_45218342的博客
11-13 882
但在此基础上，我们需要强加两个隐藏条件以保证其展示的效果是最佳的，局面是最复杂的，并且每一个迷宫里的格子和墙都是有意义的。
迷宫算法 之 迷宫生成和迷宫寻路
Globalizationa的博客
06-14 3204
本文讲解迷宫生成和迷宫寻路算法。 //////////////////////////////////////////////////////////////////////////////////////////////////// 一、三种迷宫生成算法 　　　　1、 DFS（即深度优先）算法生成，分为递归和非递归方法。 　　　　2、 十字分割算法生成，分为递归和非递归方法。 　　　　3、随机 Prim 算法生成，一种非递归方法。 二、两种迷宫寻路算法 　　　　1、DFS 寻路，采用非...
深度优先算法生成迷宫的举例
05-27
深度优先算法可以用来生成迷宫，常见的实现方法是随机深度优先搜索算法（Randomized Depth-First Search Algorithm）。下面以随机深度优先搜索算法为例，来说明如何生成迷宫。 1. 初始化一个二维数组maze表示迷宫，将所有元素都设置为墙。 2. 从起点开始，将起点标记为已访问，将起点加入栈中。 3. 当栈不为空时，从栈顶取出一个节点，随机选择一个未访问过的相邻节点，将该节点标记为已访问，将该节点加入栈中，并将两个节点之间的墙打通。 4. 如果当前节点没有未访问的相邻节点，将该节点出栈，回溯到上一个节点。 5. 重复步骤3和4，直到所有节点都被访问过。 例如，下图是一个5x5的迷宫，使用随机深度优先搜索算法生成的结果： ``` +---+---+---+---+---+ | | | +---+---+---+---+ + | | +---+ + +---+ + | | | +---+ +---+ + + | | | +---+---+---+---+---+ ``` 其中，墙用符号"|"和"-"表示，空格表示通路。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值