迷宫递归除法算法

编程问答 2022-06-13

问题描述

我目前正在用Python制作一个随机迷宫生成器，将其值存储在二维数组中。将来，它将用作我的寻路算法测试仪。 我尝试使用递归除法算法来实现这一点，因为对我来说，这似乎是最直观的。

我没有使用Python的经验。

为了尽可能多地组合，我为用户提供了选择高度和宽度的选项，

def dimensions():
    height = int(input("Desired height: "))
    width = int(input("Desired width: "))

    res = (height,width)
    return res

根据算法规则，我创建了一个空的数组，该数组由墙包围，并具有起点和终点，分别为：

def create_array(height,width):
    maze = np.zeros((height,width),dtype = int)

    for i in range(height):
        maze[i][0] = 1
        maze[i][width - 1] = 1
    
    for i in range(width):
        maze[0][i] = 1
        maze[height - 1][i] = 1
        

    return maze

def set_start_end(start,height = 0,width = 0):
    if start == True:
        elems = [0,1]
        random.shuffle(elems)

    else:
        elems = [[height - 1,width - 2],[height - 2,width - 1]]
        elems = random.choice(elems)

    res = (elems[0],elems[1])

    return res

再次从左上角和右下角选择起点和终点，以允许更多可能的组合。

在此之后，我创建了3个辅助功能：

def choose_orientation(height,width):
    if width > height:
        return VERTICAL
    elif width < height:
        return HORIZONTAL
    else:
        return random.choice((VERTICAL,HORIZONTAL))

def set_wall(length):
    coor = int(length/2)

    if (coor % 2 != 0):
        coor += random.choice([-1,1])
    
    return coor

def set_door(length):
    coor = random.randrange(1,length - 1)

    if (coor % 2 == 0):
        coor += random.choice([-1,1])
    
    return coor

第一个方法很简单，它根据房间的当前高度和宽度选择创建墙壁的方向。 以下两个功能可确保仅在偶数单元中创建墙，而在对面创建门。

我的主要递归循环如下：

def divide(maze,x,y,height,width,resolution):
    h = height
    w = width

    if w <= resolution or h <= resolution:
        return

    orientation = choose_orientation(h,w)

    w_coor = 0
    w_length = 0
    d_coor = 0
    
    if orientation == HORIZONTAL:
        w_coor = set_wall(w)
        d_coor = set_door(w)

        w_length = w

        for i in range(w_length):
            maze[x + w_coor][i] = 1
        
        maze[w_coor][d_coor] = 0
    
        for elem in [[y,w_coor - y + 1],[w_coor,y + h - w_coor - 1]]:
            divide(maze,elem[0],elem[1],w,resolution)

    else:
        w_coor = set_wall(h)
        d_coor = set_door(h)

        w_length = h
         
        for i in range(w_length):
            maze[i][y + w_coor] = 1
        
        maze[d_coor][w_coor] = 0

        for elem in [[x,w_coor - x + 1],x + w - w_coor - 1]]:
            divide(maze,h,resolution)

然而，结果总以某种方式类似于以下内容：

[[1 5 1 1 1 1 1 1 1 1]
 [1 0 0 0 1 0 0 0 1 1]
 [1 1 1 0 1 0 0 0 1 1]
 [1 0 0 0 1 0 0 0 1 1]
 [1 0 1 1 1 1 1 1 1 1]
 [1 0 0 0 0 0 0 0 1 1]
 [1 0 0 0 0 0 0 0 0 1]
 [1 0 0 0 0 0 0 0 0 1]
 [1 1 1 1 1 1 0 0 0 1]
 [1 1 1 1 1 1 1 1 5 1]]

我无法发现问题，也不知道该怎么办

按照@Stef的回答，我已经将给set_wall和set_door的参数切换了，给了我更好的结果

[[1 1 1 1 1 1 1 1 1 1]
 [5 0 1 0 1 0 1 0 1 1]
 [1 0 1 0 1 0 1 0 1 1]
 [1 0 0 0 0 0 1 0 1 1]
 [1 1 1 0 1 1 1 0 1 1]
 [1 0 0 0 0 0 1 0 1 1]
 [1 1 1 1 0 0 0 0 0 1]
 [1 0 0 0 0 0 0 0 0 1]
 [1 0 0 0 0 0 0 0 0 5]
 [1 1 1 1 1 1 1 1 1 1]]

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）

algorithmalgorithmmazepythonrecursion