A*搜索算法的启发性策略--八数码问题实现（附代码）

一、问题描述

什么是A*搜索算法？
A星搜索算法，也称最佳图搜索算法。这是一种在图形平面上，有多个节点的路径，求出最优路径的算法。A算法是一种启发式搜索算法，启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无谓的搜索路径，提高了效率。

二、实验目的

本实验主要是理解A*搜索算法的启发性策略。

三、实验内容

（1）A*算法描述

A* 算法加入了启发式的搜索策略，在搜索时间上通常优于 Dijkstra 算法。A* 使用了一个估计值 F 代表某一个节点到终点的估计距离，计算公式如下：

其中，G（n）表示从起点到节点n的真实距离，
H（n）表示用启发函数计算的节点n到终点的距离。
另外 A* 包含两个列表，open list 和 close list，open list 保存了等待探索的节点，而 close list 表示已经探索过的节点。

（2）问题的搜索形式描述

状态：状态描述了8个棋子和空位在棋盘上的9个方格上的分布。
初始状态：任何状态都可以被指定为初始状态。
操作符：用来产生4个行动（上下左右移动）。
目标测试：用来检测状态是否能匹配初始状态。
启发函数：根据启发函数找到F(n)的值，然后根据F（n）的值的大小来排列待扩展状态的次序，每次选择F(n)最小的状态进行扩展。

（3）实验步骤

步骤一：把起点 s 放入到 open list 里面。
步骤二：检查 open list，如果终点 e 在 open list 里面，则路径搜索完成。如果 open list 为空，则说明不存在路径。
步骤三：在 open list 里面选择估计值 F 最小的节点 u，作为当前节点，然后加入 close list 里面。
步骤四：取得所有节点 u 可以直接到达的节点 v，然后更新 open list。更新规则：如果 v 在 close list 里，则不处理；如果 v 不在 open list 里面，则把 v 加入 open list，其对应 F 值为 G(u)+distance(u,v)+H(v)；如果 v 在 open list 里面，则检查 v 是否有更小的 F 值 (如果有更小 F 值，就更新 v 的 F 值)；
重复步骤二到步骤四，直到终止。

（4）主要代码（python实现）

import numpy as np
import operator

O = int(input(("请输入方阵的行/列数：")))
A = list(input("请输入初始状态："))
B = list(input("请输入目标状态："))
z = 0
M = np.zeros((O, O))
N = np.zeros((O, O))

for i in range(O):
    for j in range(O):
        M[i][j] = A[z]
        N[i][j] = B[z]
        z = z + 1
openlist = []  # open表


class State:
    def __init__(self, m):
        self.node = m  # 节点代表的状态
        self.f = 0  # f(n)=g(n)+h(n)
        self.g = 0  # g(n)
        self.h = 0  # h(n)
        self.father = None  # 节点的父亲节点


init = State(M)  # 初始状态
goal = State(N)  # 目标状态


# 启发函数
def h(s):
    a = 0
    for i in range(len(s.node)):
        for j in range(len(s.node[i])):
            if s.node[i][j] != goal.node[i][j]:
                a = a + 1
    return a


# 对节点列表按照估价函数的值的规则排序
def list_sort(l):
    cmp = operator.attrgetter('f')
    l.sort(key=cmp)


# A*算法
def A_star(s):
    global openlist  # 全局变量可以让open表进行时时更新
    openlist = [s]
    while (openlist):  # 当open表不为空
        get = openlist[0]  # 取出open表的首节点
        if (get.node == goal.node).all():  # 判断是否与目标节点一致
            return get
        openlist.remove(get)  # 将get移出open表
        # 判断此时状态的空格位置
        for a in range(len(get.node)):
            for b in range(len(get.node[a])):
                if get.node[a][b] == 0:
                    break
            if get.node[a][b] == 0:
                break
        # 开始移动
        for i in range(len(get.node)):
            for j in range(len(get.node[i])):
                c = get.node.copy()
                if (i + j - a - b) ** 2 == 1:
                    c[a][b] = c[i][j]
                    c[i][j] = 0
                    new = State(c)
                    new.father = get  # 此时取出的get节点成为新节点的父亲节点
                    new.g = get.g + 1  # 新节点与父亲节点的距离
                    new.h = h(new)  # 新节点的启发函数值
                    new.f = new.g + new.h  # 新节点的估价函数值
                    openlist.append(new)  # 加入open表中
        list_sort(openlist)  # 排序


# 递归打印路径
def printpath(f):
    if f is None:
        return
    # 注意print()语句放在递归调用前和递归调用后的区别。放在后实现了倒叙输出
    printpath(f.father)
    print(f.node)


final = A_star(init)
if final:
    print("有解，解为：")
    printpath(final)
else:
    print("无解")

四、实验结果及分析

以8数码问题为例实现A*算法的求解程序运行结果：

分析：
1.对于8数码问题，每个节点有8个数字和一个空格，可以将空格看成0，所以一共有9个数字。从初始状态到最终状态，进行路径搜索。
2.启发函数：每一个数字位与目标中该数字位的距离，满足单调限制。说明：A*算法是启发式搜索算法，搜索时充分利用当前状态距目标距离远近的启发信息，选取当前未扩展结点中估价函数最小的进行扩展，生成结点数少，搜索空间较小，实现稍复杂。
3.算法分析
将起始点加入open表
当open表不为空时：
寻找open表中f值最小的点current
它是终止点，则找到结果，程序结束。
否则，Open表移出current，对current表中的每一个临近点
若它不可走或在close表中，略过
若它不在open表中，加入。
若它在open表中，计算g值，
若g值更小，替换其父节点为current，更新它的g值。
若open表为空，则路径不存在。

五、遇到的问题及解决办法

1.判断有无解问题

根据逆序数直接判断有无解，对于一个八数码，依次排列之后，每次是将空位和相邻位进行调换，研究后会发现，每次调换，逆序数增幅都为偶数，也就是不改变奇偶性，所以初始和目标状态的逆序数的奇偶性相同。

2.解决结点重复扩展问题

对于一个结点有多种方式到达该结点，这样就可能多次将它加入open表中，而启发函数满足单调限制条件，后来达到该结点的路径不再是更优的，可以不予考虑。扩展某结点时先看该结点是否已经扩展过，如果扩展过则略过。

3.A* 启发函数的选择与区别

如果不设置启发函数，则 A* 就是 Dijkstra 算法，这时可以找到最短路径。如果启发函数 H(n) 的值一定小于等于 n 到终点的实际距离，则 A* 可以保证找到最短路径。如果 H(n) 的值等于 n 到终点的实际距离，则 A* 会直接找到最短路径，而不用扩展搜索额外的节点，此时运行是最快的。如果 H(n) 的值有可能大于 n 到终点的实际距离，则 A* 算法不一定可以找到最短路径，但是运行速度会比较快。