Python 四大迷宫生成算法实现(1): 递归回溯算法

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/marble_xu/article/details/88201319

递归回溯算法简介

下图是算法使用的地图，地图最外围默认是一圈墙，其中白色单元是迷宫单元，黑色单元是墙，相邻白色单元之前的墙是可以被去掉的。可以看到这个地图中所有的迷宫单元在地图中的位置(X,Y），比如（1，1），（5，9）都是奇数，可以表示成(2 * x+1, 2 * y+1), x和y的取值范围从0到4。在迷宫生成算法中会用到这个表示方式。同时迷宫的长度和宽度必须为奇数。

递归回溯是一个深度优先算法，如果当前单元有相邻的未访问过的迷宫单元，就一直向前搜索，直到当前单元没有未访问过的迷宫单元，才返回查找之前搜索路径上未访问的迷宫单元，所以用堆栈来维护已访问过的迷宫单位。

算法主循环，重复下面步骤2直到堆栈为空：
1 随机选择一个迷宫单元作为起点，加入堆栈并标记为已访问
2 当堆栈非空时，从栈顶获取一个迷宫单元（不用出栈），进行循环

• 如果当前迷宫单元有未被访问过的相邻迷宫单元
  • 随机选择一个未访问的相邻迷宫单元
  • 去掉当前迷宫单元与相邻迷宫单元之间的墙
  • 标记相邻迷宫单元为已访问，并将它加入堆栈
• 否则，当前迷宫单元没有未访问的相邻迷宫单元
  • 则栈顶的迷宫单元出栈

关键代码介绍

保存基本信息的地图类

地图类用于保存和获取迷宫算法使用的基础地图信息。

1. 先创建一个map类， 初始化参数设置地图的长度和宽度，并设置保存地图信息的二维数据map的值为0， 值为0表示该单元可以移动，值为1表示该单元是墙。定义在算法中用到的Enum 类MAP_ENTRY_TYPE 和 WALL_DIRECTION。

class MAP_ENTRY_TYPE(Enum):
	MAP_EMPTY = 0,
	MAP_BLOCK = 1,

class WALL_DIRECTION(Enum):
	WALL_LEFT = 0,
	WALL_UP = 1,
	WALL_RIGHT = 2,
	WALL_DOWN = 3,

class Map():
	def __init__(self, width, height):
		self.width = width
		self.height = height
		self.map = [[0 for x in range(self.width)] for y in range(self.height)]

2. 在map类中添加将整个map单元设置为某个值的函数，设置某个单元为某个值的函数，和某个单元是否被访问的函数。

	def resetMap(self, value):
		for y in range(self.height):
			for x in range(self.width):
				self.setMap(x, y, value)
	
	def setMap(self, x, y, value):
		if value == MAP_ENTRY_TYPE.MAP_EMPTY:
			self.map[y][x] = 0
		elif value == MAP_ENTRY_TYPE.MAP_BLOCK:
			self.map[y][x] = 1
	
	def isVisited(self, x, y):
		return self.map[y][x] != 1

3. 在map类中添加一个显示地图的函数，可以看到，这边只是简单的打印出所有节点的值，值为1时打印’#"表示强，或1的意思上面已经说明，在后面显示寻路算法结果时，会使用到值2，表示一条从开始节点到目标节点的路径。

	def showMap(self):
		for row in self.map:
			s = ''
			for entry in row:
				if entry == 0:
					s += ' 0'
				elif entry == 1:
					s += ' #'
				else:
					s += ' X'
			print(s)

算法主函数介绍

doRecursiveBacktracker 函数 先调用resetMap函数将地图都设置为墙，迷宫单元所在位置为墙表示未访问。有个注意点是地图的长宽和迷宫单元的位置取值范围的对应关系。
假如地图的宽度是31，长度是21，对应的迷宫单元的位置取值范围是 x(0,15), y(0,10), 因为迷宫单元(x,y)对应到地图上的位置是(2 * x+1, 2 * y+1)。
recursiveBacktracker 函数就是上面算法主循环的实现。

# recursive backtracker algorithm
def recursiveBacktracker(map, width, height):
	startX, startY = (randint(0, width-1), randint(0, height-1))
	print("start(%d, %d)" % (startX, startY))
	map.setMap(2*startX+1, 2*startY+1, MAP_ENTRY_TYPE.MAP_EMPTY)
	
	checklist = [] 
	checklist.append((startX, startY))
	while len(checklist):
		# use checklist as a stack, get entry from the top of stack 
		entry = checklist[-1]
		if not checkAdjacentPos(map, entry[0], entry[1], width, height, checklist):
			# the entry has no unvisited adjacent entry, so remove it from checklist
			checklist.remove(entry)
			
def doRecursiveBacktracker(map):
	# set all entries of map to wall
	map.resetMap(MAP_ENTRY_TYPE.MAP_BLOCK)
	recursiveBacktracker(map, (map.width-1)//2, (map.height-1)//2)

checkAdjacentPos 函数检查当前迷宫单元的是否有未访问的相邻单元，如果有，则随即选取一个相邻单元，标记未已访问，并去掉当前迷宫单元与相邻迷宫单元之间的墙。如果没有，则不做操作。

# find unvisited adjacent entries of four possible entris
# then add random one of them to checklist and mark it as visited
def checkAdjacentPos(map, x, y, width, height, checklist):
	directions = []
	if x > 0:
		if not map.isVisited(2*(x-1)+1, 2*y+1):
			directions.append(WALL_DIRECTION.WALL_LEFT)
				
	if y > 0:
		if not map.isVisited(2*x+1, 2*(y-1)+1):
			directions.append(WALL_DIRECTION.WALL_UP)

	if x < width -1:
		if not map.isVisited(2*(x+1)+1, 2*y+1):
			directions.append(WALL_DIRECTION.WALL_RIGHT)
		
	if y < height -1:
		if not map.isVisited(2*x+1, 2*(y+1)+1):
			directions.append(WALL_DIRECTION.WALL_DOWN)
		
	if len(directions):
		direction = choice(directions)
		if direction == WALL_DIRECTION.WALL_LEFT:
				map.setMap(2*(x-1)+1, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				map.setMap(2*x, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				checklist.append((x-1, y))
		elif direction == WALL_DIRECTION.WALL_UP:
				map.setMap(2*x+1, 2*(y-1)+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				map.setMap(2*x+1, 2*y, MAP_ENTRY_TYPE.MAP_EMPTY)
				checklist.append((x, y-1))
		elif direction == WALL_DIRECTION.WALL_RIGHT:
				map.setMap(2*(x+1)+1, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				map.setMap(2*x+2, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				checklist.append((x+1, y))
		elif direction == WALL_DIRECTION.WALL_DOWN:
			map.setMap(2*x+1, 2*(y+1)+1, MAP_ENTRY_TYPE.MAP_EMPTY)
			map.setMap(2*x+1, 2*y+2, MAP_ENTRY_TYPE.MAP_EMPTY)
			checklist.append((x, y+1))
		return True
	else:
		# if not find any unvisited adjacent entry
		return False

代码的初始化

可以调整地图的长度，宽度，注意长度和宽度必须为奇数。

def run():
	WIDTH = 31
	HEIGHT = 21
	map = Map(WIDTH, HEIGHT)
	doRecursiveBacktracker(map)
	map.showMap()	
	
if __name__ == "__main__":
	run()

执行的效果图如下，start 表示第一个随机选择的迷宫单元。迷宫中’#'表示墙，'0’表示通道。

完整代码

使用python3.7编译

from random import randint, choice
from enum import Enum

class MAP_ENTRY_TYPE(Enum):
	MAP_EMPTY = 0,
	MAP_BLOCK = 1,

class WALL_DIRECTION(Enum):
	WALL_LEFT = 0,
	WALL_UP = 1,
	WALL_RIGHT = 2,
	WALL_DOWN = 3,

class Map():
	def __init__(self, width, height):
		self.width = width
		self.height = height
		self.map = [[0 for x in range(self.width)] for y in range(self.height)]
	
	def resetMap(self, value):
		for y in range(self.height):
			for x in range(self.width):
				self.setMap(x, y, value)
	
	def setMap(self, x, y, value):
		if value == MAP_ENTRY_TYPE.MAP_EMPTY:
			self.map[y][x] = 0
		elif value == MAP_ENTRY_TYPE.MAP_BLOCK:
			self.map[y][x] = 1
	
	def isVisited(self, x, y):
		return self.map[y][x] != 1

	def showMap(self):
		for row in self.map:
			s = ''
			for entry in row:
				if entry == 0:
					s += ' 0'
				elif entry == 1:
					s += ' #'
				else:
					s += ' X'
			print(s)

# find unvisited adjacent entries of four possible entris
# then add random one of them to checklist and mark it as visited
def checkAdjacentPos(map, x, y, width, height, checklist):
	directions = []
	if x > 0:
		if not map.isVisited(2*(x-1)+1, 2*y+1):
			directions.append(WALL_DIRECTION.WALL_LEFT)
				
	if y > 0:
		if not map.isVisited(2*x+1, 2*(y-1)+1):
			directions.append(WALL_DIRECTION.WALL_UP)

	if x < width -1:
		if not map.isVisited(2*(x+1)+1, 2*y+1):
			directions.append(WALL_DIRECTION.WALL_RIGHT)
		
	if y < height -1:
		if not map.isVisited(2*x+1, 2*(y+1)+1):
			directions.append(WALL_DIRECTION.WALL_DOWN)
		
	if len(directions):
		direction = choice(directions)
		#print("(%d, %d) => %s" % (x, y, str(direction)))
		if direction == WALL_DIRECTION.WALL_LEFT:
				map.setMap(2*(x-1)+1, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				map.setMap(2*x, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				checklist.append((x-1, y))
		elif direction == WALL_DIRECTION.WALL_UP:
				map.setMap(2*x+1, 2*(y-1)+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				map.setMap(2*x+1, 2*y, MAP_ENTRY_TYPE.MAP_EMPTY)
				checklist.append((x, y-1))
		elif direction == WALL_DIRECTION.WALL_RIGHT:
				map.setMap(2*(x+1)+1, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				map.setMap(2*x+2, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
				checklist.append((x+1, y))
		elif direction == WALL_DIRECTION.WALL_DOWN:
			map.setMap(2*x+1, 2*(y+1)+1, MAP_ENTRY_TYPE.MAP_EMPTY)
			map.setMap(2*x+1, 2*y+2, MAP_ENTRY_TYPE.MAP_EMPTY)
			checklist.append((x, y+1))
		return True
	else:
		# if not find any unvisited adjacent entry
		return False
			
# recursive backtracker algorithm
def recursiveBacktracker(map, width, height):
	startX, startY = (randint(0, width-1), randint(0, height-1))
	print("start(%d, %d)" % (startX, startY))
	map.setMap(2*startX+1, 2*startY+1, MAP_ENTRY_TYPE.MAP_EMPTY)
	
	checklist = [] 
	checklist.append((startX, startY))
	while len(checklist):
		# use checklist as a stack, get entry from the top of stack 
		entry = checklist[-1]
		if not checkAdjacentPos(map, entry[0], entry[1], width, height, checklist):
			# the entry has no unvisited adjacent entry, so remove it from checklist
			checklist.remove(entry)
			
def doRecursiveBacktracker(map):
	# set all entries of map to wall
	map.resetMap(MAP_ENTRY_TYPE.MAP_BLOCK)
	recursiveBacktracker(map, (map.width-1)//2, (map.height-1)//2)

def run():
	WIDTH = 31
	HEIGHT = 21
	map = Map(WIDTH, HEIGHT)
	doRecursiveBacktracker(map)
	map.showMap()	
	
if __name__ == "__main__":
	run()