书接上文。在坦克寻径的，tank_way中，A*算法每一步搜索都是选择F值最小的节点，步步为营，使得寻径的结果是最优解。在这个过程中，查找最小F值的算法复杂度是O(n)，这对于小地图没什么问题，但是对于大地图来说，openlist将会保存大量的节点信息，此时如果每次循环仍然使用O(n)复杂度的算法去查找最小F值就是个非常严重的问题了，这将导致游戏运行缓慢。可以针对这一点行改进，在常数时间内查找到最小F值的节点。
一个现成的数据结构是优先队列，python的heapq模块已经实现了这个功能，它是基于堆优先队列，可以中O(1)时间内返回堆中的最小值。我们用heapq存储openlist中的节点，构建新的坦克寻径代码：
import heapq START, END = (), () # 起点和终点的位置 OBSTRUCTION = 1 # 障碍物标记 class Node: def __init__(self, x, y, parent): self.x = x # 节点的行号 self.y = y # 节点的列号 self.parent = parent # 父节点 self.h = 0 self.g = 0 self.f = 0 def get_G(self): ''' 当前节点到起点的代价 ''' if self.g != 0: return self.g elif self.parent is None: self.g = 0 # 当前节点在parent的垂直或水平方向 elif self.parent.x == self.x or self.parent.y == self.y: self.g = self.parent.get_G() + 10 # 当前节点在parent的斜对角 else: self.g = self.parent.get_G() + 14 return self.g def get_H(self): '''节点到终点的距离估值 ''' if self.h == 0: self.h = self.manhattan(self.x, self.y, END[0], END[1]) * 10 return self.h def get_F(self): ''' 节点的评估值 ''' if self.f == 0: self.f = self.get_G() + self.get_H() return self.f def manhattan(self, from_x, from_y, to_x, to_y): ''' 曼哈顿距离 ''' return abs(to_x - from_x) + abs(to_y - from_y) def __lt__(self, other): ''' 用于堆比较，返回堆中f最小的一个 ''' return self.get_F() < other.get_F() def __eq__(self, other): ''' 判断Node是否相等 ''' return self.x == other.x and self.y == other.y def __ne__(self, other): ''' 判断Node是否不等 ''' return not self.__eq__(other) class Tank_way: ''' 使用A*搜索找到坦克的最短移动路径 ''' def __init__(self, map2d): self.map2d = map2d # 地图数据 self.x_edge, self.y_edge = len(map2d), len(map2d[0]) # 地图边界 # 垂直和水平方向的差向量 self.v_hv = [(-1, 0), (0, 1), (1, 0), (0, -1)] # 斜对角的差向量 self.v_diagonal = [(-1, 1), (1, 1), (1, -1), (-1, -1)] self.openlist = [] # openlist使用基于堆的优先队列 self.closelist = set() self.answer = None def is_in_map(self, x, y): ''' (x, y)是否中地图内 ''' return 0 <= x < self.x_edge and 0 <= y < self.y_edge def in_closelist(self, x, y): ''' (x, y) 方格是否在closeList中 ''' return (x, y) in self.closelist def add_in_openlist(self, node): ''' 将node添加到 openlist ''' heapq.heappush(self.openlist, node) def add_in_closelist(self, node): ''' 将node添加到 closelist ''' self.closelist.add((node.x, node.y)) def pop_min_F(self): ''' 弹出openlist中F值最小的节点 ''' return heapq.heappop(self.openlist) def append_Q(self, P): ''' 找到P周围可以探索的节点,将其加入openlist，并返回这些节点 ''' Q = {} # 将水平或垂直方向的相应方格加入到Q for dir in self.v_hv: x, y = P.x + dir[0], P.y + dir[1] # 如果(x,y)不是障碍物并且不在closelist中，将(x,y)加入到Q if self.is_in_map(x, y) and self.map2d[x][y] != OBSTRUCTION and not self.in_closelist(x, y): node = Node(x, y, P) Q[(x, y)] = node heapq.heappush(self.openlist, node) # 将node同时放入openlist中 # 将斜对角的相应方格加入到Q for dir in self.v_diagonal: x, y = P.x + dir[0], P.y + dir[1] # 如果(x,y)不是障碍物，且(x,y)能够与P联通，且(x,y)不在closelist中，将(x,y)加入到Q if self.is_in_map(x, y) and self.map2d[x][y] != OBSTRUCTION and self.map2d[x][P.y] != OBSTRUCTION and self.map2d[P.x][y] != OBSTRUCTION and not self.in_closelist(x, y): node = Node(x, y, P) Q[(x, y)] = node heapq.heappush(self.openlist, node) # 将node同时放入openlist中 return Q def a_search(self): while self.openlist: # 找到openlist中F值最小的节点作为探索节点 P = self.pop_min_F() # 如果P在closelist中，执行下一次循环 if self.in_closelist(P.x, P.y): continue # P加入closelist self.add_in_closelist(P) # P周围待探索的节点 Q = self.append_Q(P) # Q中没有任何节点，表示该路径一定不是最短路径，重新从openlist中选择 if not Q: continue # 找到了终点， 退出循环 if Q.get(END) is not None: self.answer = Node(END[0], END[1], P) break def start(self): node_start = Node(START[0], START[1], None) self.add_in_openlist(node_start) self.a_search() def paint(self): ''' 打印最短路线 ''' node = self.answer while node is not None: print((node.x, node.y), 'G={0}, H={1}, F={2}'.format(node.g, node.h, node.get_F())) node = node.parent if __name__ == '__main__': map2d = [[0] * 8 for i in range(8)] map2d[5][4] = 1 map2d[5][5] = 1 map2d[4][5] = 1 map2d[3][5] = 1 map2d[2][5] = 1 START, END = (3, 2), (5, 7) a_way = Tank_way(map2d) a_way.start() a_way.paint()
Tank_way_2省略的代码和Tank_way一致。为了让openlist能够返回F值最小值的节点，需要在Node中添加三个额外的方法。对于pop_min_F()而言，不再需要遍历所有节点，仅仅是从堆顶弹出而已，这将大大缩短程序运行的时间。在Tank_way_2中，用append_Q代替了原来来的get_Q()，这是因为不再需要用Q中的节点和openlist中的节点相比较，仅仅是将Q中的节点添加到openlist中。这样做虽然会使得openlist中存在一些重复节点，不过没关系，对于有相同标记的节点，F值小的那个总是最先弹出，一旦弹出就会加入到closelist中，这意味着当该标记的节点再次弹出时，将不会被使用，也就是说，如果同一个标记的节点被计算了多次F值，总是能够确保使用F值最小的那个，并丢弃其它的。
再战觐天宝匣
基于盲目策略的广度优先收索无法有效完成4阶以上的拼图（可参考搜索的策略（3）——觐天宝匣上的拼图），在理解了A*搜索后，可以用这种启发性策略再次挑战觐天宝匣的拼图。
设计评估函数
如果将拼图的每一次移动看作“一步”，只要能定义出离评估函数和代价函数，就可以像坦克寻径一样使用A*搜索寻找拼图的复原步骤。
我们将g(n)定义为从起点移动到某个状态的步数；h(n)是当前状态到复原状态的距离估值，它用所有碎片的曼哈顿距离之和表示。以3×3的拼图为例，假设拼图的某个状态和复原状态是：
左图中，3号碎片的位置是(2,0)，它在复原状态的位置是(1,0)，则3号碎片的曼哈顿距离是|2-1|+|0-0|=1。同理，5号碎片的曼哈顿距离是|0-1|+|1-2|=2。左图距复原状态的曼哈顿距离是所有碎片的曼哈顿距离之和：
其中Dn表示第n个碎片的曼哈顿距离，图眼的编号是8。
复原拼图
有了g和h就可以开始复原拼图，复原过程和坦克的寻路类似。从拼图的初始状态开始，第一步可以向三个方向探测，从而产生三种状态：
此后每一步都选择最小的F值继续探索，如果F值相同，则选择最后加入openlist中的一个：
最终的复原步骤如图：
实现A*搜索
拼图的实现和坦克寻径类似，完整代码如下：
import random import copy import heapq IMG_END = [] # 拼图的复原状态 EYE_VAL = ' ' # 图眼的值 DIST = {} def get_hash_value(img): ''' 获取img的哈希值 ''' return hash(str(img)) class Node: def __init__(self, img, x=0, y=0, parent=None): self.img = img # 当前拼图 self.x, self.y = x, y # 图眼在img中的位置 self.parent = parent # 父节点 self.hash_value = get_hash_value(img) # Node的哈希值 self.h = 0 self.g = 0 self.f = 0 def get_G(self): ''' 当前节点到起点的代价 ''' if self.g != 0: return self.g elif self.parent is None: self.g = 0 else: self.g = self.parent.get_G() + 1 return self.g def get_H(self): ''' 节点到终点的距离估值 ''' if self.h == 0: self.h = self.manhattan() return self.h def get_F(self): ''' 节点的评估值 ''' if self.f == 0: self.f = self.get_G() + self.get_H() # self.f = self.get_H() return self.f def manhattan(self): '' '当前拼图到复原状态的距离 ''' d = DIST.get(self.hash_value) if d is not None: return d dist = 0 x_end, y_end = 0, 0 # img_end 中某一个碎片的位置 n = len(self.img) for x, row in enumerate(self.img): for y, piece in enumerate(row): if piece == IMG_END[x][y]: continue # 计算piece碎片在img_end中的位置 if piece == EYE_VAL: x_end = n - 1 y_end = n - 1 else: x_end = piece // n y_end = piece - n * x_end dist += abs(x - x_end) + abs(y - y_end) DIST[self.hash_value] = dist return dist def __lt__(self, other): ''' 用于堆比较，返回堆中f最小的一个 ''' return self.get_F() < other.get_F() def __eq__(self, other): ''' 判断Node是否相等 ''' return self.img.hash_value == other.img.hash_value def __ne__(self, other): ''' 判断Node是否不等 ''' return not self.__eq__(other) def __hash__(self): return self.hash_value class JigsawPuzzle_A: ''' 用A*搜索复原拼图 ''' def __init__(self, level=1, img_start=None): self.level = level # 难度系数 self.n = len(IMG_END) # 拼图的维度 self.end_hash_value = get_hash_value(IMG_END) # 复原状态的哈希值 # “图眼”移动的方向, 上、左、下、右 self.v_move = [(0, 1), (-1, 0), (0, -1), (1, 0)] # 设置拼图的初始状态和图眼的位置 if img_start is not None: self.img_start = img_start self.eye_x, self.eye_y = self.search_eye(img_start) else: self.img_start, self.eye_x, self.eye_y = self.confuse() self.openlist = [] self.closelist = set() # 拼图复原步骤 self.answer = None def confuse(self): ''' 创建一个n*n的拼图，返回打乱状态和图眼位置 ''' # 拼图的初始状态 img_start = copy.deepcopy(IMG_END) from_x, from_y = self.search_eye(IMG_END) to_x, to_y = from_x, from_y # 将图眼随机移动 n * n * level次 for i in range(self.n * self.n * self.level): # 选择一个随机方向 v_x, v_y = random.choice(self.v_move) to_x, to_y = from_x + v_x, from_y + v_y if self.enable(to_x, to_y): # 向选择的随机方向移动 self.move(img_start, from_x, from_y, to_x, to_y) from_x, from_y = to_x, to_y else: to_x, to_y = from_x, from_y return img_start, to_x, to_y def search_eye(self, img): ''' 找到img中图眼的位置 ''' # “图眼”的值是eye_val，打乱顺序后需要寻找到图眼的位置 for x in range(self.n): for y in range(self.n): if EYE_VAL == img[x][y]: return x, y def in_closelist(self, node): ''' node 是否在closelist中 ''' return node.hash_value in self.closelist def add_in_openlist(self, node): ''' node节点加入openlist ''' heapq.heappush(self.openlist, node) def add_in_closelist(self, node): ''' node节点加入closelist ''' self.closelist.add(node.hash_value) def pop_min_F(self): ''' 找到openlist中F值最小的节点 ''' return heapq.heappop(self.openlist) def enable(self, to_x, to_y): ''' 图眼是否能够移动到x,y的位置 ''' return 0 <= to_x < self.n and 0 <= to_y < self.n def move(self, img, from_x, from_y, to_x, to_y): ''' 将图眼从from_x, from_y移动到to_x, to_y ''' img[from_x][from_y], img[to_x][to_y] = img[to_x][to_y], img[from_x][from_y] def append_Q(self, P): ''' 找到P周围可以探索的节点,将其加入openlist，并返回这些节点 ''' Q = {} for v_x, v_y in self.v_move: to_x, to_y = P.x + v_x, P.y + v_y # 检验是否可以向to_x, to_y方向移动 if not self.enable(to_x, to_y): continue curr_img = copy.deepcopy(P.img) self.move(curr_img, P.x, P.y, to_x, to_y) # 如果node是不在closelist中，把node添加到Q中 if not self.in_closelist(Node(curr_img)): node = Node(curr_img, x=to_x, y=to_y, parent=P) Q[node.hash_value] = node self.add_in_openlist(node) return Q def a_search(self): ''' A*搜索拼图的解 ''' while self.openlist: # 找到openlist中F值最小的节点作为探索节点 P = self.pop_min_F() # 如果P在closelist中，执行下一次循环 if self.in_closelist(P): continue # P加入closelist self.add_in_closelist(P) # P周围待探索的节点 Q = self.append_Q(P) # Q中没有任何节点，表示该路径一定不是最短路径，重新从openlist中选择 if not Q: continue # 找到了终点， 退出循环 if Q.get(self.end_hash_value) is not None: self.answer = Node(IMG_END, parent=P) break def start(self): if self.img_start == IMG_END: print('start = end') return node_start = Node(img=self.img_start, x=self.eye_x, y=self.eye_y) self.add_in_openlist(node_start) self.a_search() def display(self): if self.answer is None: print('No answer') node = self.answer while node is not None: print(node.img) node = node.parent def create_img_end(n): ''' 创建一个n*n的拼图，将右下角的碎片图指定为图眼 ''' img = [] for i in range(n): img.append(list(range(n * i, n * i + n))) img[n - 1][n - 1] = EYE_VAL return img if __name__ == '__main__': n = 9 IMG_END = create_img_end(n) # img_start = [[3, 0, 2], [1, 7, EYE_VAL], [6, 5, 4]] jigsaw = JigsawPuzzle_A(level=5) print('start=', jigsaw.img_start, ',eye =', (jigsaw.eye_y, jigsaw.eye_x)) jigsaw.start() jigsaw.display()
JigsawPuzzle_A中额外设置了难度系数，level的值越大，复原拼图越困难。对于一个拼图来说，level=5已经足以打乱顺序：
九九拼图的复原已经非人力所能解决。JigsawPuzzle_A可以快速复原任意难度的4×4拼图，对于更高阶的拼图，即使是A*搜索，面对的搜索数量依然十分庞大，需要耗费相当长的时间，只有level=1的时候 9×9拼图才能快速得到结果。
作者：我是8位的
