Python 四大迷宫生成算法实现(4): 生成树+并查集算法
python迷宫生成算法实现：生成树+并查集算法
- 生成树算法简介
- 并查集算法简介
- 关键代码介绍
- 保存基本信息的地图类
- 算法主函数介绍
- 代码的初始化
- 完整代码
生成树算法简介
先看下生成树Kruskal算法：
1 一开始将每个点作为单独的一棵树，选择一个起点和终点。
2 循环执行，随机选择一条边，判断边连接的顶点，是否在同一子树中。
- 如果不是，则连通这两个顶点，把他们任意一个添加到另一个所在的子树中。
- 如果是，则判断起点和终点是否在同一子树中。如果在同一子树中，表示已经生成了一颗树，则退出循环。
上面生成树算法中的边可以看成是迷宫中的墙，但是在实现时要同时记录墙和迷宫单元的信息，会比较复杂，所以使用改进版本，只维护一个迷宫单元的列表，判断迷宫单元和它相邻的迷宫单元是否在同一棵树中。
合并两个顶点的时候，想要实现高效率的话，使用线性表肯定是不行的，所以这里需要使用UFS(Union_Find_Set)并查集。
下图是算法使用的地图，地图最外围默认是一圈墙，其中白色单元是迷宫单元，黑色单元是墙，相邻白色单元之前的墙是可以被去掉的。可以看到这个地图中所有的迷宫单元在地图中的位置(X,Y），比如（1，1），（5，9）都是奇数，可以表示成(2 * x+1, 2 * y+1), x和y的取值范围从0到4。在迷宫生成算法中会用到这个表示方式。同时迷宫的长度和宽度必须为奇数。
算法主循环，重复下面步骤2直到检查列表为空：
1 将每个迷宫单元都初始化为单独的一棵树，并加入检查列表。
2 当检查列表非空时，随机从列表中取出一个迷宫单元，检查当前迷宫单元和它的相邻迷宫单元，是否属于同一棵树。
- 如果有相邻迷宫单元不属于同一棵树，随机选择一个这样的相邻迷宫单元
- 使用并查集方法将这个相邻迷宫单元和当前迷宫单元合并成一颗树
- 否则，表示当前迷宫单元和相邻的迷宫单元都属于同一棵树
- 则从检查列表删除当前迷宫单元
并查集算法简介
并查集存储
每棵树都有一个唯一的根节点，可以用它来代表这个树所有节点所在的Set。
- 初始化：每个节点(x, y)看做一棵树，当然这是一棵只有根节点的树，将这个节点的值作为set的标识。
- 查询：对于节点(x,y)，通过节点的值不断查找它的父节点，直到找到所在树的根节点；
在我们的代码实现中，比如迷宫地图的高度为10，则一个迷宫单元(x,y), 它的节点值为： index = x*height+y。parentlist[index] 表示它的父节点值。初始化时，parentlist[index] = index，表示节点的父节点是它自己。
parentlist = [x*height+y for x in range(width) for y in range(height)]
判断两个节点是否属于同一棵树
这个很简单，找到两个节点(x1,y1) 和 (x2, y2) 所在树的根节点，判断两个根节点是否相同。
并查集合并规则
在每棵树的根节点存储一个属性 weight，用来表示这棵树拥有的子节点数，节点数多的是“大树”，少的就是“小树”。有一个合并两棵子树的原则是小树变成大树的子树，这样生成的树更加平衡。
比如下面的两颗树，(x,y) 表示迷宫单元的位置，第一个表示树的根节点。
- 合并前
(2,2) <= (3,2)
(0,3) <= (2,4) <= (3,3) - 小树变成大树的子树合并后，根节点为(0, 3)，树高度为3
<= (2,2) <= (3,2)
(0,3)
<= (2,4) <= (3,3) - 如果大树变成小树的子树合并后，根节点为(2, 2)，树高度为4
<= (3,2)
(2,2)
<= (0,3) <= (2,4) <= (3,3)
关键代码介绍
保存基本信息的地图类
这个和之前的递归回溯算法使用相同的地图类，这里就省略了。
算法主函数介绍
doUnionFindSet 函数 先调用resetMap函数将地图都设置为墙。有个注意点是地图的长宽和迷宫单元的位置取值范围的对应关系。
假如地图的宽度是31，长度是21，对应的迷宫单元的位置取值范围是 x(0,15), y(0,10), 因为迷宫单元(x,y)对应到地图上的位置是(2 * x+1, 2 * y+1)。
unionFindSet 函数就是上面算法主循环的实现。这边会先做初始化，将地图中的迷宫单元设为空，添加所有迷宫单元到 checklist 检查列表。
parentlist 表示每个迷宫单元的父节点，初始化为迷宫单元自己，即单独的一棵树。
weightlist 表示每个迷宫单元的权重，初始化为1，在合并子树时使用，保证生成树的平衡，防止生成树的高度过大。
def unionFindSet(map, width, height):
parentlist = [x*height+y for x in range(width) for y in range(height)]
weightlist = [1 for x in range(width) for y in range(height)]
checklist = []
for x in range(width):
for y in range(height):
checklist.append((x,y))
# set all entries to empty
map.setMap(2*x+1, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
while len(checklist):
# select a random entry from checklist
entry = choice(checklist)
if not checkAdjacentPos(map, entry[0], entry[1], width, height, parentlist, weightlist):
checklist.remove(entry)
def doUnionFindSet(map):
# set all entries of map to wall
map.resetMap(MAP_ENTRY_TYPE.MAP_BLOCK)
unionFindSet(map, (map.width-1)//2, (map.height-1)//2)
checkAdjacentPos 函数 检查当前迷宫单元和它的相邻迷宫单元，是否属于同一棵树。如果存在不属于同一棵树的相邻迷宫单元列表，则从中选取一个，打通当前迷宫单元和这个相邻迷宫单元之间的墙，并合并成一颗树。
def checkAdjacentPos(map, x, y, width, height, parentlist, weightlist):
directions = []
node1 = getNodeIndex(x,y)
root1 = findSet(parentlist, node1)
# check four adjacent entries, add any unconnected entries
if x > 0:
root2 = findSet(parentlist, getNodeIndex(x-1, y))
if root1 != root2:
directions.append(WALL_DIRECTION.WALL_LEFT)
if y > 0:
root2 = findSet(parentlist, getNodeIndex(x, y-1))
if root1 != root2:
directions.append(WALL_DIRECTION.WALL_UP)
if x < width -1:
root2 = findSet(parentlist, getNodeIndex(x+1, y))
if root1 != root2:
directions.append(WALL_DIRECTION.WALL_RIGHT)
if y < height -1:
root2 = findSet(parentlist, getNodeIndex(x, y+1))
if root1 != root2:
directions.append(WALL_DIRECTION.WALL_DOWN)
if len(directions):
# choose one of the unconnected adjacent entries
direction = choice(directions)
if direction == WALL_DIRECTION.WALL_LEFT:
adj_x, adj_y = (x-1, y)
map.setMap(2*x, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
elif direction == WALL_DIRECTION.WALL_UP:
adj_x, adj_y = (x, y-1)
map.setMap(2*x+1, 2*y, MAP_ENTRY_TYPE.MAP_EMPTY)
elif direction == WALL_DIRECTION.WALL_RIGHT:
adj_x, adj_y = (x+1, y)
map.setMap(2*x+2, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
elif direction == WALL_DIRECTION.WALL_DOWN:
adj_x, adj_y = (x, y+1)
map.setMap(2*x+1, 2*y+2, MAP_ENTRY_TYPE.MAP_EMPTY)
node2 = getNodeIndex(adj_x, adj_y)
unionSet(parentlist, node1, node2, weightlist)
return True
else:
# the four adjacent entries are all connected, so can remove this entry
return False
findSet 函数返回迷宫单元所在树的根节点。
getNodeIndex 函数返回迷宫单元 (x, y) 的树节点index。
unionSet 函数进行合并两颗树的操作
# find the root of the tree which the node belongs to
def findSet(parent, index):
if index != parent[index]:
return findSet(parent, parent[index])
return parent[index]
def getNodeIndex(x, y):
return x * height + y
# union two unconnected trees
def unionSet(parent, index1, index2, weightlist):
root1 = findSet(parent, index1)
root2 = findSet(parent, index2)
if root1 == root2:
return
if root1 != root2:
# take the high weight tree as the root,
# make the whole tree balance to achieve everage search time O(logN)
if weightlist[root1] > weightlist[root2]:
parent[root2] = root1
weightlist[root1] += weightlist[root2]
else:
parent[root1] = root2
weightlist[root2] += weightlist[root1]
代码的初始化
可以调整地图的长度，宽度，注意长度和宽度必须为奇数。
def run():
WIDTH = 31
HEIGHT = 21
map = Map(WIDTH, HEIGHT)
doRecursiveBacktracker(map)
map.showMap()
if __name__ == "__main__":
run()
执行的效果图如下，start 表示第一个随机选择的迷宫单元。迷宫中’#‘表示墙，空格’ '表示通道。
完整代码
使用python3.7编译，有一个debug 函数printTree,可以打印出最后生成的树结构。
from random import 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 showMap(self):
for row in self.map:
s = ''
for entry in row:
if entry == 0:
s += ' '
elif entry == 1:
s += ' #'
else:
s += ' X'
print(s)
def unionFindSet(map, width, height):
# find the root of the tree which the node belongs to
def findSet(parent, index):
if index != parent[index]:
return findSet(parent, parent[index])
return parent[index]
def getNodeIndex(x, y):
return x * height + y
# union two unconnected trees
def unionSet(parent, index1, index2, weightlist):
root1 = findSet(parent, index1)
root2 = findSet(parent, index2)
if root1 == root2:
return
if root1 != root2:
# take the high weight tree as the root,
# make the whole tree balance to achieve everage search time O(logN)
if weightlist[root1] > weightlist[root2]:
parent[root2] = root1
weightlist[root1] += weightlist[root2]
else:
parent[root1] = root2
weightlist[root2] += weightlist[root2]
# For Debug: print the generate tree
def printPath(parent, x, y):
node = x * height + y
path = '(' + str(node//height) +','+ str(node%height)+')'
node = parent[node]
while node != parent[node]:
path = '(' + str(node//height) +','+ str(node%height)+') <= ' + path
node = parent[node]
path = '(' + str(node//height) +','+ str(node%height)+') <= ' + path
print(path)
def printTree(parent):
for x in range(width):
for y in range(height):
printPath(parentlist, x, y)
def checkAdjacentPos(map, x, y, width, height, parentlist, weightlist):
directions = []
node1 = getNodeIndex(x,y)
root1 = findSet(parentlist, node1)
# check four adjacent entries, add any unconnected entries
if x > 0:
root2 = findSet(parentlist, getNodeIndex(x-1, y))
if root1 != root2:
directions.append(WALL_DIRECTION.WALL_LEFT)
if y > 0:
root2 = findSet(parentlist, getNodeIndex(x, y-1))
if root1 != root2:
directions.append(WALL_DIRECTION.WALL_UP)
if x < width -1:
root2 = findSet(parentlist, getNodeIndex(x+1, y))
if root1 != root2:
directions.append(WALL_DIRECTION.WALL_RIGHT)
if y < height -1:
root2 = findSet(parentlist, getNodeIndex(x, y+1))
if root1 != root2:
directions.append(WALL_DIRECTION.WALL_DOWN)
if len(directions):
# choose one of the unconnected adjacent entries
direction = choice(directions)
if direction == WALL_DIRECTION.WALL_LEFT:
adj_x, adj_y = (x-1, y)
map.setMap(2*x, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
elif direction == WALL_DIRECTION.WALL_UP:
adj_x, adj_y = (x, y-1)
map.setMap(2*x+1, 2*y, MAP_ENTRY_TYPE.MAP_EMPTY)
elif direction == WALL_DIRECTION.WALL_RIGHT:
adj_x, adj_y = (x+1, y)
map.setMap(2*x+2, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
elif direction == WALL_DIRECTION.WALL_DOWN:
adj_x, adj_y = (x, y+1)
map.setMap(2*x+1, 2*y+2, MAP_ENTRY_TYPE.MAP_EMPTY)
node2 = getNodeIndex(adj_x, adj_y)
unionSet(parentlist, node1, node2, weightlist)
return True
else:
# the four adjacent entries are all connected, so can remove this entry
return False
parentlist = [x*height+y for x in range(width) for y in range(height)]
weightlist = [1 for x in range(width) for y in range(height)]
checklist = []
for x in range(width):
for y in range(height):
checklist.append((x,y))
# set all entries to empty
map.setMap(2*x+1, 2*y+1, MAP_ENTRY_TYPE.MAP_EMPTY)
while len(checklist):
# select a random entry from checklist
entry = choice(checklist)
if not checkAdjacentPos(map, entry[0], entry[1], width, height, parentlist, weightlist):
checklist.remove(entry)
#printTree(parentlist)
def doUnionFindSet(map):
# set all entries of map to wall
map.resetMap(MAP_ENTRY_TYPE.MAP_BLOCK)
unionFindSet(map, (map.width-1)//2, (map.height-1)//2)
def run():
WIDTH = 31
HEIGHT = 21
map = Map(WIDTH, HEIGHT)
doUnionFindSet(map)
map.showMap()
if __name__ == "__main__":
run()