详细介绍如何利用 A star（A*）算法解决8数码问题_a*算法如何解决八数码问题

---

1. A star（A*）算法简介

$A^{\ast }$ 算法是一种常用的高效图搜索算法，用于在静态图中找到从起始节点到目标节点的最短路径。它结合了 $Dijkstra$ 算法和 启发式（贪心）搜索算法的思想，通过使用“启发式函数”来控制搜索过程，从而提高大部分场景下的搜索效率。

$Dijkstra$ 算法 （一种标号法）是每次优先搜索距离起始节点最近的待搜索节点，常用在带权值的路径搜素问题当中，这是典型的广度优先搜索，该算法能保证找到最短路，也常用在多目标节点或无目标节点的场景（挖宝游戏），但是这类算法在寻路场景下往往效率较低，需要花费大量的时间探索各个方向；启发式（贪心）搜索算法 则恰恰相反，它每次优先探索距离目标节点最近的节点，在无障碍的地图上，该算法效率极高，但如果有障碍，贪心搜索并不能保证找到的路线是最短的，或者遇到像挖宝这种无目标节点的场景则无法计算与目标的距离。

$A^{\ast }$ 算法 在考虑探索节点的优先顺序时，既考虑了与起始节点的距离，又考虑了与目标节点的预估距离，即综合考虑：从起始节点出发，经过当前节点到目标节点的总的估计代价（距离），既能保证找到最短路径，又能比广度优先搜索有更高的效率。

2. 利用A*解决8数码问题（含Python代码）

2.1 什么是8数码问题

8数码问题是一个经典的搜索问题。在一个 $3\times 3$ 的棋盘上，放着数字 $1$ 到 $8$，还有 $1$ 个位置空着，通过交换空格与相邻位置的数字，来移动空格（只能上下左右），该问题会给出一个初始的棋盘顺序，以及期望的棋盘顺序，问最少移动多少下空格，能将初始顺序改变为目标顺序？

听着是不是有点像华容道

把空格的移动视作是棋盘顺序的移动，且这种对应关系是确定的，因此可以把8数码问题视为一个路径优化问题，每个棋盘顺序是一个节点。那么现在有个关键的问题，就是如何确定棋盘顺序（节点）与棋盘顺序（节点）之间的距离大小呢？ 有两种简单的计算方法：

1. 计算两个顺序中，未正确摆放的数字数量，对于目标顺序，该值为 $0$，该方法仅关注未摆放正确的数字数量，计算方法简单，但实际中，往往又不是这么回事，相同的错摆数量，确实不同的调整难度，如下例子：

   $$\begin{gathered} 1,2,32,3 \\ 4,5,\to 4,5,6 \\ 7,8,67,8,1 \end{gathered}$$

2. 另一个距离公式是所有数字 $1-8$ 在两个棋盘顺序中的位置距离之和，而对于二维棋盘上数字的位置，可以用一维的索引值表示，也可以用行列坐标表示，例如上面的例子，数字 $6$ 在左边棋盘的位置可以是 $8$，也可以是 $(2,2)$。

2.2 A*算法中的开放列表和关闭列表

在 $A^{\ast }$ 算法中，有两个重要的数据结构：开放列表（open list）和关闭列表（closed list）。开放列表用于存储待探索的节点，每次向前迭代时，算法会从中取出一个估计代价最小的节点进行探索；关闭列表则是存储已经探索过的节点，对于不同的路线，可能会探索到相同的节点，因此关闭列表可以帮助我们避免重复探索。

这里有个加速技巧，即每次从开放列表中取出估计代价最小的节点，且每次探索时也要往开放列表中添加节点，频繁的取小操作可以考虑用“小根堆”的数据结构，具体实现可以利用 heapq 库，存取操作如下：

import heapq

node_set = [[[1,2,3], 0], [[11,2,3], 2], [[111,2,3], -0.4]]

# 定义一个空的小根堆
open_list = []

# 将节点及其估计代价存入小根堆
for item in node_set:
    heapq.heappush(open_list, (item[1], item[0]))

# 从小根堆中取出值最小的节点
if len(open_list) > 0:
    print("取出估计代价最小的节点：", heapq.heappop(open_list))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：在从小根堆中取节点时，要先判断一下堆中是否还有节点，否则从一个空堆中取值会报 IndexError 错误。而且这里我们传入根的内容包含两个值，当第一个值大小一样，则会判断第二个值的大小，如果第二个值无法比较大小（例如我们存储的是一个对象类型），则需要打破第一个值的等值关系。

2.3 A*算法解决8数码问题过程

给出 $8$ 数码问题的起始顺序和目标顺序（从左到右，从上到下遍历）如下：

init = "724506831"
targ = "012345678"
1
2

实现 $A^{\ast }$ 算法需创建 $4$ 个函数（函数名自定义），分别需要实现的功能是：

1. solve()：$A^{\ast }$ 算法的主程序，根据传入的起始顺序，和目标顺序返回最（次）短的操作路径；
2. dist()：计算传入的两个节点（棋盘顺序）的距离；
3. moveNode()：传入当前节点，以及棋盘上待交换的数字，返回交换后的棋盘顺序；

由于 solve() 中会用到第 $2,3$ 的函数，因此放在后置位介绍。在一开始，建立名为 $Node$ 的类，包含了以下属性，self.value 表示节点的数字顺序，self.start_seq 表示起始顺序，self.end_seq 表示目标顺序，这两者在本问题下的所有 $Node$ 对象中都一致。self.parent_node 是节点的父节点，指向上一个节点对象，self.g_value 是节点到起始节点的实际代价（在本案例中，这里的代价是指移动空格的次数，初始节点的移动次数为 $0$），self.h_value 是节点到目标节点的预估代价（本案例中用曼哈顿距离表示），self.f_value 是经由当前节点，从起始节点到目标节点的预估代价。

class Node:
    def __init__(self, start_seq, end_seq, value=None, parent_node=None):
        self.start_seq = start_seq
        self.end_seq = end_seq
        self.value = value
        self.parent_node = parent_node
        self.g_value = 0
        self.h_value = dist(self.end_seq, self.value)
        self.f_value = self.g_value + self.h_value
    
    def add_g_value(self, add_v):
        self.g_value += add_v
        self.h_value = dist(self.end_seq, self.value)
        self.f_value = self.g_value + self.h_value
    
    def set_g_value(self, new_v):
        self.g_value = new_v
        self.h_value = dist(self.end_seq, self.value)
        self.f_value = self.g_value + self.h_value
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

注意：由于后续生成新的 Node 对象是通过对父节点进行深拷贝获得的，因此会直接拷贝父节点的属性值，但在该类中，self.h_value 和 self.f_value 是通过计算公式获得的（这只有在初始化时才会执行计算），且这两个属性值都在 self.g_value 发生变化时需要进行更新，因此增加了 add_g_value 和 set_g_value 中的更新操作。

2.3.1 计算节点（棋盘顺序）间距离

根据前面提到的计算两个节点距离的内容，这里我们用一维的数组表示节点状态，即棋盘中的数字顺序，可以直接通过一维坐标 index 计算距离：

$$d(nod{e}_1,nod{e}_2)=\sum _{i=0}^8|inde{x}_i^1-inde{x}_i^2|$$

也可以通过行列坐标进行计算，通过地板除法和取余操作可以将一维的位置信息转化为二维坐标信息 $(x,y)$。然后计算两个坐标之间的曼哈顿距离，遍历所有的数字（$0$ 表示空格），然后找到数字在传入序列中的位置，再将位置信息转换为坐标信息进行计算。距离计算公式如下：

$$d(nod{e}_1,nod{e}_2)=\sum _{i-0}^8(|x_i^1-x_i^2|+|y_i^1-y_i^2|)$$

两种距离计算方法的实现代码如下：

def dist(node1_seq: list, node2_seq: list) -> int:
    dist_res = 0
    for i in range(len(node1_seq)):
        node1_index = node1_seq.index(i)
        node2_index = node2_seq.index(i)
        dist_res += 50 * abs(node1_index - node2_index)
        # dist_res += 5 * (abs(node1_index//3 - node2_index//3) + abs(node1_index%3 - node2_index%3))
    return dist_res
1
2
3
4
5
6
7
8

注意：在前面提到，我们会综合考虑 g_value 和 h_value 的值，因此两者的量级关系对最终的优化效率和结果有很大影响，当前者量级更大，则倾向于遍历尽可能多的情况，以找到最短的移动路径；当后者量级更大，则倾向于快速找到近似解，不能保证找到最优解，但能增强算法的收敛性，能在合理时间内返回可行的结果，因此在实际代码中，可以根据情况调整系数。

2.3.2 交换数字生成新的节点

由于这里提到的节点是指棋盘的顺序，因此从一个节点移动到另一个节点，需要对节点当中的数字的位置进行调换，调换的动作（上 $u$ 下 $d$ 左 $l$ 右 $r$）会生成新的节点（棋盘顺序），以便 $A^{\ast }$ 找到的路径持续向前推进，具体代码如下：

def moveNode(node: Node, i, j) -> Node:
    node_res = deepcopy(node)   
    node_res.value[i], node_res.value[j] = node_res.value[j], node_res.value[i]
    node_res.add_g_value(1)
    return node_res
1
2
3
4
5

由于是基于探索节点，向各个方向延伸 $1$ 步，因此需要对新节点的 g_value 进行更新。

2.3.3 A*主求解程序

1. 首先基于传入的数字序列，创建起始节点，并将起始节点加入到待探索的节点列表当中 open_node_list；
2. 只要待探索的节点列表不为空，就每次从中取出 f_value 值最小的节点 next_explore_node 进行探索，当探索该节点时，将节点放入到 closed_node_list，用以防止后续对相同的节点进行重复探索；
   • 遍历四个移动方向，如果该移动方向可行（不超过棋盘范围），则生成新的节点 frontier_node，如果该节点的排列与目标节点排列一致，则跳出循环；反之则要判断是否加入待探索节点列表
3. 当探索的节点的排列与目标节点排列一致时，终止搜索，并由该探索节点一层层往上打印父节点的排列，直到回溯到起始节点（parent_node=None）。

如果探索节点的相邻节点的排列顺序，已被探索过，则默认忽略该节点，这是因为两个节点的 h_value 相等，但后探索的节点的 g_value 会更大，显然后碳素哟节点不会比先探索的节点更好，且经由后探索节点的路径不会比经由先探索节点的路径更短。

def solve(start_node: str, end_node: str):
    start_seq = [int(char) for char in start_node]
    end_seq = [int(char) for char in end_node]
    start_node = Node(start_seq=start_seq, end_seq=end_seq, value=start_seq)

    move_direct = {"u": [-1, 0], "d": [1, 0], "l": [0, -1], "r": [0, 1]}
    open_node_list, closed_node_list = [], []
    heapq.heappush(open_node_list, (start_node.f_value, start_node))

    while open_node_list:
        try:
            next_explore_node = heapq.heappop(open_node_list)[1]
        except TypeError:
            next_explore_node = open_node_list[0][1]
            open_node_list.pop(0)
        closed_node_list.append(next_explore_node)

        open_seq_list = [node[1].value for node in open_node_list]
        closed_seq_list = [node.value for node in closed_node_list]

        for explore_direct, change in move_direct.items():
            from_index = next_explore_node.value.index(0)
            row, col = from_index//3, from_index%3
            new_row, new_col = row + change[0], col + change[1]
            if (0 <= new_row <= 2) and (0 <= new_col <= 2):
                to_index = 3 * new_row + new_col
                frontier_node = moveNode(next_explore_node, from_index, to_index)
                frontier_node.parent_node = next_explore_node
                if frontier_node.value in closed_seq_list:
                    continue
                else:   
                    if frontier_node.value not in open_seq_list:    
                        eps = 0
                        while True:
                            try:
                                heapq.heappush(open_node_list, (frontier_node.f_value + eps, frontier_node))
                                break
                            except TypeError:
                                eps += 0.001
                    else:
                        for node in open_node_list: 
                            if frontier_node.value == node[1].value:
                                if frontier_node.g_value < node[1].g_value:
                                    node[1].set_g_value(frontier_node.g_value)
                                break

        if next_explore_node.value == next_explore_node.end_seq:
            print(next_explore_node.value)
            while next_explore_node.parent_node:
                print(next_explore_node.parent_node.value)
                next_explore_node = next_explore_node.parent_node
            break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

求解开头提到的两个排列，经过 $0.28s$ 得到 $40$ 步的结果，如下：

[0, 1, 2, 3, 4, 5, 6, 7, 8]
[3, 1, 2, 0, 4, 5, 6, 7, 8]
[3, 1, 2, 6, 4, 5, 0, 7, 8]
[3, 1, 2, 6, 4, 5, 7, 0, 8]
[3, 1, 2, 6, 0, 5, 7, 4, 8]
[3, 1, 2, 0, 6, 5, 7, 4, 8]
[0, 1, 2, 3, 6, 5, 7, 4, 8]
[1, 0, 2, 3, 6, 5, 7, 4, 8]
[1, 2, 0, 3, 6, 5, 7, 4, 8]
[1, 2, 5, 3, 6, 0, 7, 4, 8]
[1, 2, 5, 3, 0, 6, 7, 4, 8]
[1, 2, 5, 3, 4, 6, 7, 0, 8]
[1, 2, 5, 3, 4, 6, 7, 8, 0]
[1, 2, 5, 3, 4, 0, 7, 8, 6]
[1, 2, 0, 3, 4, 5, 7, 8, 6]
[1, 0, 2, 3, 4, 5, 7, 8, 6]
[0, 1, 2, 3, 4, 5, 7, 8, 6]
[3, 1, 2, 0, 4, 5, 7, 8, 6]
[3, 1, 2, 4, 0, 5, 7, 8, 6]
[3, 1, 2, 4, 5, 0, 7, 8, 6]
[3, 1, 2, 4, 5, 6, 7, 8, 0]
[3, 1, 2, 4, 5, 6, 7, 0, 8]
[3, 1, 2, 4, 0, 6, 7, 5, 8]
[3, 1, 2, 0, 4, 6, 7, 5, 8]
[3, 1, 2, 7, 4, 6, 0, 5, 8]
[3, 1, 2, 7, 4, 6, 5, 0, 8]
[3, 1, 2, 7, 4, 6, 5, 8, 0]
[3, 1, 2, 7, 4, 0, 5, 8, 6]
[3, 1, 2, 7, 0, 4, 5, 8, 6]
[3, 0, 2, 7, 1, 4, 5, 8, 6]
[0, 3, 2, 7, 1, 4, 5, 8, 6]
[7, 3, 2, 0, 1, 4, 5, 8, 6]
[7, 3, 2, 5, 1, 4, 0, 8, 6]
[7, 3, 2, 5, 1, 4, 8, 0, 6]
[7, 3, 2, 5, 0, 4, 8, 1, 6]
[7, 0, 2, 5, 3, 4, 8, 1, 6]
[7, 2, 0, 5, 3, 4, 8, 1, 6]
[7, 2, 4, 5, 3, 0, 8, 1, 6]
[7, 2, 4, 5, 3, 6, 8, 1, 0]
[7, 2, 4, 5, 3, 6, 8, 0, 1]
[7, 2, 4, 5, 0, 6, 8, 3, 1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41