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

最新推荐文章于 2021-12-26 14:44:17 发布
最新推荐文章于 2021-12-26 14:44:17 发布
阅读量1.4k 收藏 4
点赞数 1
分类专栏： 迷宫生成与寻路算法
本文链接：https://blog.csdn.net/defaultbyzt/article/details/115465668
版权

python 迷宫生成算法

随机Kruskal算法

随机Kruskal算法介绍

这个算法是Kruskal算法的随机化版本。

  • 1。创建所有墙壁的列表，并为每个单元格创建一个集合，每个集合只包含一个单元格。
  • 2。对于每一面墙，以随机的顺序访问:
    • 1。如果由这个墙壁分隔的单元格属于不同的集合:
      • 1。移除当前的墙。
      • 2。合并被这面墙分开的两个集合。

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

Python代码

#!/usr/bin/python3.7
# -*- coding: utf-8 -*-
import random
import pygame
# Randomized Kruskal's algorithm
# This algorithm is a randomized version of Kruskal's algorithm.
# 1.Create a list of all walls, and create a set for each cell, each containing just that one cell.
# 2.For each wall, in some random order:
#    1.If the cells divided by this wall belong to distinct sets:
#        1.Remove the current wall.
#        2.Join the sets of the formerly divided cells.
# 随机的Kruskal算法
# 这个算法是Kruskal算法的随机化版本。
# 1。创建所有墙壁的列表，并为每个单元格创建一个集合，每个单元格只包含一个单元格。
# 2。对于每一面墙，以一些随机的顺序:
#   1。如果由这个壁分隔的细胞属于不同的集合:
#       1。移除当前的墙。
#       2。加入以前分裂的细胞组。

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

# 随机格子
def kruskal_maze(rows, cols):
    # 墙 [0]表示格子访问标记，右[1]竖墙，下[2]横墙
    # (最左和最上墙不能打通，r,c右和r,c+1左共用墙。下墙同理)
    # 初始化未访问，墙未打通
    grids=[[ [0,0,0] for i in range(cols)]for i in range(rows)]
    # 设置起点
    r=0
    c=0
    # 格子列表
    gridlist=[]
    gridlist.append((r,c))
    # 单元格集合
    collection =[]
    # 墙壁的列表
    walls=[]
    for r in range(rows):
        for c in range(cols):
            collection.append([(r,c)])
            for x in range(1,3):
                # 最右和最下的墙不能打通
                if r == rows - 1 and x == 2:
                    continue
                if c == cols - 1 and x == 1:
                    continue
                walls.append((r,c,x))

    while walls:
        # 随机选一个墙
            r,c,x = random.choice(walls)
            # a,b相邻的集合
            if x == 1: # 竖墙
                a = (r,c)
                b = (r,c+1)
            else :  # 横墙
                a = (r,c)
                b = (r+1,c)
            coll1 = []
            coll2 = []
            for coll in collection:
                if a in coll:
                    coll1 = coll
                if b in coll:
                    coll2 = coll
            # 设置访问过
            grids[a[0]][a[1]][0] = 1
            grids[b[0]][b[1]][0] = 1
            # 
            if coll1 == coll2:
                walls.remove((r,c,x))
            else:
                # 打通墙
                grids[r][c][x] = 1
                # 
                coll = coll1+coll2
                collection.remove(coll1)
                collection.remove(coll2)
                collection.append(coll)
                walls.remove((r,c,x))
        
    return grids



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

演示代码:

#!/usr/bin/python3.7
# -*- coding: utf-8 -*-
import random
import pygame
# Randomized Kruskal's algorithm
# This algorithm is a randomized version of Kruskal's algorithm.
# 1.Create a list of all walls, and create a set for each cell, each containing just that one cell.
# 2.For each wall, in some random order:
#    1.If the cells divided by this wall belong to distinct sets:
#        1.Remove the current wall.
#        2.Join the sets of the formerly divided cells.

# 随机的Kruskal算法
# 这个算法是Kruskal算法的随机化版本。
# 1。创建所有墙壁的列表，并为每个单元格创建一个集合，每个单元格只包含一个单元格。
# 2。对于每一面墙，以一些随机的顺序:
#   1。如果由这个壁分隔的细胞属于不同的集合:
#       1。移除当前的墙。
#       2。加入以前分裂的细胞组。

# 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])
# 
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)
# 行列
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 kruskal_maze_demo(rows, cols):
    # 墙 [0]表示格子访问标记，右[1]竖墙，下[2]横墙
    # (最左和最上墙不能打通，r,c右和r,c+1左共用墙。下墙同理)
    # 初始化未访问，墙未打通
    grids=[[ [0,0,0] for i in range(cols)]for i in range(rows)]
    # 设置起点
    r=0
    c=0
    # 格子列表
    gridlist=[]
    gridlist.append((r,c))
    # 单元格集合
    collection =[]
    # 墙壁的列表
    walls=[]
    for r in range(rows):
        for c in range(cols):
            collection.append([(r,c)])
            for x in range(1,3):
                # 最右和下的墙不能打通
                if r == rows - 1 and x == 2:
                    continue
                if c == cols - 1 and x == 1:
                    continue
                walls.append((r,c,x))

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

        if  walls:
            # 随机选一个墙
            r,c,x = random.choice(walls)
            # 每个墙随机到一次
            walls.remove((r,c,x))
            # a,b相邻的集合
            if x == 1: # 竖墙
                a = (r,c)
                b = (r,c+1)
            else :  # 横墙
                a = (r,c)
                b = (r+1,c)
            coll1 = []
            coll2 = []
            for coll in collection:
                if a in coll:
                    coll1 = coll
                if b in coll:
                    coll2 = coll
            # 设置访问过
            grids[a[0]][a[1]][0] = 1
            grids[b[0]][b[1]][0] = 1
            # 
            if coll1 != coll2:
                # 打通墙
                grids[r][c][x] = 1
                # 合并集合
                coll = coll1+coll2
                collection.remove(coll1)
                collection.remove(coll2)
                collection.append(coll)

        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))

        # 画外墙
        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 walls:
            # 列表中的墙
            for rw,cw,xw in walls:
                px,py=21 + (cw) * DIAMOND_SIZE[0], 21 + (rw) * DIAMOND_SIZE[1]
                color = COLOR[COLOR_GREEN]
                if xw == 1:
                    pygame.draw.line(screen, color, (px, py-20), (px, py), 2)
                else:
                    pygame.draw.line(screen, color, (px-20, py), (px, py), 2)
                    
            px,py=21 + (c) * DIAMOND_SIZE[0], 21 + (r) * DIAMOND_SIZE[1]
            color = COLOR[COLOR_GOLDEN]
            if x == 1:
                pygame.draw.line(screen, color, (px, py-20), (px, py), 2)
            else:
                pygame.draw.line(screen, color, (px-20, py), (px, py), 2)

        # 
        if not walls:
            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'''
    kruskal_maze_demo(20, 30)

GIF动画:

在这里插入图片描述

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

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

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

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

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

张拓1070410059
关注
专栏目录
深度优先，Kruskal,Prim几种方式生成迷宫地图
aabbcc729的博客
04-18 3176
深度优先，Kruskal,Prim几种方式生成迷宫地图
三大迷宫生成算法 (Maze generation algorithm) -- 深度优先，随机Prim，递归分割
热门推荐
Much effort, much prosperity.
06-12 7万+
之前同学参加面试，面试官问到迷宫生成算法，这个问题自己想了下也没有好办法，所有就查询了相关资料。这里进行了相关整理： 本文主要讲解的迷宫生成算法有三种： 1.Recursive backtracker ( 递归回溯，也是深度优先算法） 2.Randomized Prim's algorithm（随机Prim算法，让我想起了最小生成树的Prim算法） 3.Recursive division
maze-maker:使用 Kruskal 算法创建迷宫。 也解决了
06-01
迷宫制造者 使用 Kruskal 算法创建迷宫。 也解决了他们。
python迷宫选自你也看得懂的算法_Kruskal迷宫算法的Python实现问题
weixin_39744240的博客
12-10 110
fromturtleimport*fromrandomimportrandrange,choiceGRID_SIZE=5CELL_SIZE=50RIGHT,BOTTOM=1,2# Choice 1 cuts the right wall and choice 2 cuts the bottom walldefonline(position,line):x,y=position(firstx,fir...
JavaMazeGame:使用Kruskal算法使用BFS或DFS随机生成可解迷宫
05-11
通过使用深度优先搜索或广度优先搜索（取决于用户指定的内容）随机生成可解决的迷宫。 用Java编写，并使用东北大学的“ impworld”库绘制迷宫。
Kruskal——小希的迷宫
dgjm4087的博客
03-08 252
Description 上次Gardon的迷宫城堡小希玩了很久（见Problem B），现在她也想设计一个迷宫让Gardon来走。但是她设计迷宫的思路不一样，首先她认为所有的通道都应该是双向连通的，就是说如果有一个通道连通了房间A和B，那么既可以通过它从房间A走到房间B，也可以通过它从房间B走到房间A，为了提高难度，小希希望任意两个房间有且仅有一条路径可以相通（除非走了回头路）...
【随机化贪心】【Kruskal】【NOI2005】小H的聚会
void* ptr = &OI;
06-05 3154
【任务描述】 小 H 从小就非常喜欢计算机,上了中学以后,他更是迷上了计算机编程。经过多年的不懈努力,小 H 幸运的被选入信息学竞赛省队,就要去他日思夜想的河南郑州参加第 22 届全国信息学奥林匹克竞赛(NOI2005)。 小 H 的好朋友小 Y 和小 Z 得知了这个消息,都由衷的为他感到高兴。 他们准备举办一个 party,邀请小 H 和他的所有朋友参加,为小 H 庆祝一下。 经过好几天的调查,
随机算法 randomized algorithm
10-05
随机算法（Randomized Algorithm）是计算机科学中一种重要的算法类型，它在执行过程中利用了概率或随机数来做出决策或生成解。这种算法通常用于解决复杂的问题，因为它们能够提供有效的近似解，并且在某些情况下，其...
Pathfinding-Visualizer:可视化五种寻路算法和迷宫生成算法
05-09
路径查找和迷宫生成算法可视化工具 内置VanillaJs，HTML和CSS 该应用程序将五种不同的寻路算法和五种迷宫生成算法可视化。 您可以一次可视化一个算法，也可以同时可视化多个算法。 最多有四个网格可用，在每个网格...
迷宫生成算法(Randomized Prim‘s algorithm)
04-02 687
算法 #!/usr/bin/python3.7 # -*- coding: utf-8 -*- import random #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 t
蓄水池算法leetcode-randomized-algorithm:随机算法
06-30
蓄水池算法leetcode 固定范围采样 输入大小为 n 个项目 获取 0 到 n -1 之间的随机数 根据输入返回项目[索引] 油藏取样 概括 n项的流 n不知道提前 每个项目结果的概率相等 算法 水库采样算法旨在从未知大小的总体中...
迷宫生成算法（三）（C++)
nanfang0的博客
12-26 1567
三、最小生成树算法之Kruskal算法 迷宫算法中由于所有边的权相等，且需要随机性，所以与数据结构中的Kruskal算法有较大的不同： 将每个顶点视为一棵树，将所有边加入集合，从边的集合中随机选择一条边，如果该边两端的顶点属于不同的树，将两棵树合并，将这条边移除集合，如果属于相同树，直接舍弃这条边，直到边的集合为空，即所有边都被访问过，结束构造
pyhton随机迷宫算法生成
qq_39363022的博客
03-02 441
前言 最近在GitHub上看见一个随机迷宫算法的代码，看到蛮有意思的就拿出来分享了一下，下面将简单的介绍下随机迷宫的生成算法。一旦理解后你会发现这个算法到底有多简单。 将迷宫地图分成多个房间，每个房间都有四面墙。 让“人”从地图任意一点A出发，开始在迷宫里游荡。从A房间的1/2/3/4个方向中- 的任选一个方向前进。在从A房间走到B房间的过程中，推倒A/B房间之间的墙。 如果方向x对面的房间已经走...
python迷宫问题算法_Kruskal迷宫算法的Python实现问题
weixin_35748716的博客
02-11 207
我决定做一个可变大小的二叉树迷宫发生器。我试图使用克鲁斯卡尔的迷宫算法，我需要创建一个程序，看看是否有一种方法，让玩家从x细胞到y细胞。我在解决迷宫问题时遇到了困难。我决定在二叉树生成器中实现一个迷宫解算器，我已经有了一些基础知识，但是它有一些我无法解决的问题。在它从第一个单元格的中间开始，然后随机选择一个方向，并尝试向前移动到墙可能存在或不存在的位置，如果不可能移动，它会在另一个随机方向上再次尝...
迷宫生成算法总结
哆啦A瑶的博客
01-31 5582
最近闲来无事想做一个质量高一点的进阶版的迷宫小游戏，首先就要先生成最基础的迷宫地图，因此学习并整理了一下迷宫生成算法。由于python更容易实现这些算法，因此首先使用pyhon将各种生成算法整理一遍，之后再用Qt或者javascript重写一遍，再加上可视化。 大概了解了一下，生成迷宫的算法主要有三种思路，其中最小生成树算法又可以分为选点法（prim）和选边法（kruskal）： 随机深度优先算...
Kruskal
cj1064789374的博客
12-12 758
Kruskal
迷宫生成算法(Wilson‘s algorithm)
04-07 1370
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
primmatlab代码-Randomized_Prim_Algorithm_Experiment:Randomized_Prim_Algor
06-07
matlab代码Randomized_Prim_Algorithm_Experiment 项目名称：实验对象提案的随机Prim算法参考论文： 源代码： 报告： 总结：这个项目是 Mitchell 教授研究项目的一部分，它是为了实证研究对象建议方法如何有效地达到...
自动生成迷宫
墨染秦月的博客
01-22 5669
知识点 ①基于rank优化的并查集，用来检测两点是否相连，提高根节点查找效率 ②最小生成树，通过随机权值，生成一个随机迷宫 设计思想 可以初始化一个网格地图，然后逐渐打通其中的墙，这里以5*5网格为例，“ ”表示结点，“#”表示墙； 打通前： 可以看出，这里一共有25个结点，如果要形成迷宫，需要打破24堵结点之间的墙； 创建边Edge类，存储边的起点和终点以及权值，每个结点只和自...
Kruskal算法
Missy_xw2018的博客
05-09 1451
Kruskal算法是一种按权值的递增次序选择合适的边来构造最小生成树的方法。 对于给定的一张图，其算法思路： 将边按权值升序排序； 选出权值最小的边加入到最小生成树中，如果产生回路就放弃这条边（利用并查集来判断是否产生回路）； 重复步骤2，直到所有顶点都加入最小生成树中； 算法过程图： 将图的边按权值排序，每个顶点放在单独的集合里： （1）选出权值最小的边（0，2）加入到最小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值