八数码问题解析

八数码的问题描述为：
在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用-1来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局，找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。

解决八数码的方法很多，本文采用1.广度优先搜索的策略，和A星算法两种比较常用的算法思想解决此问题
广度优先搜索的策略一般可以描述为以下过程：

状态空间的一般搜索过程
OPEN表：用于存放刚生成的节点
CLOSE表：用于存放将要扩展或已扩展的节点

1. 把初始节点S0放入OPEN表,并建立只含S0的图,记为G
   OPEN：=S0,G：=G0（G0=S0）
2. 检查OPEN表是否为空,若为空则问题无解,退出
   LOOP：IF（OPEN）=（） THEN EXIT（FAIL）
3. 把OPEN表的第一个节点取出放入CLOSE表,记该节点为节点n
   N：=FIRST（OPEN）,REMOVE（n,OPEN）,ADD（n,CLOSE）
4. 观察节点n是否为目标节点,若是,则求得问题的解,退出
   IF GOAL（n） THEN EXIT（SUCCESS）
5. 扩展节点n,生成一组子节点.把其中不是节点n先辈的那些子节点记作集合M,并把这些节点作为节点n的子节点加入G中.
   EXPAND（n）-->M（mi）,G：=ADD（mi,G）
6. 转第2步

下面贴出代码：

import time
import copy

class list():
    def __init__(self,info):
        self.info = info
        self.front = None
            
class Solution():
    def __init__(self):
        self.open = []
        self.closed = []
        self.co = 0

    def msearch(self,S0, Sg):
        head = list(S0)
        self.open.append(head)
        while self.open:
            n = self.open.pop(0)
            self.co += 1
            print('取得节点n:',n.info) 
            if n.info == Sg:
                print('得到问题的解!')
                print('一共进行了',self.co,'次查找')
                print('该问题的解为：') #对n进行
                while n:
                    print(n.info)
                    n = n.front
                return
            if n in self.closed:
                #节点判定是否为扩展问题
                print('该结点不可扩展') 
            else:
                print('该节点可扩展')
                #扩展节点n，
                #将其子节点放入open的尾部，
                #为每一个子节点设置指向父节点的指针
                nkongdi, nkongdj = 0, 0
                for i in range(3):
                    for j in range(3):
                        if n.info[i][j] == -1:
                            nkongdi = i
                            nkongdj = j
                ln,un,rn,dn =copy.deepcopy(n.info),copy.deepcopy(n.info),copy.deepcopy(n.info),copy.deepcopy(n.info)
                if nkongdj != 0: #right
                    rn[nkongdi][nkongdj],rn[nkongdi][nkongdj-1] = rn[nkongdi][nkongdj-1],rn[nkongdi][nkongdj]
                    rn = self.link(n,rn)
                    if rn not in self.closed:
                        self.open.append(rn)
                if nkongdi != 0: #down
                    dn[nkongdi][nkongdj],dn[nkongdi-1][nkongdj] = dn[nkongdi-1][nkongdj],dn[nkongdi][nkongdj]
                    dn = self.link(n,dn)
                    if dn not in self.closed:
                        self.open.append(dn)
                if nkongdj != 2: #left
                    ln[nkongdi][nkongdj],ln[nkongdi][nkongdj+1] = ln[nkongdi][nkongdj+1],ln[nkongdi][nkongdj]
                    ln = self.link(n,ln)
                    if ln not in self.closed:
                        self.open.append(ln)
                if nkongdi != 2: #up
                    un[nkongdi][nkongdj],un[nkongdi+1][nkongdj] =  un[nkongdi+1][nkongdj],un[nkongdi][nkongdj]
                    un = self.link(n,un)
                    if un not in self.closed:
                        self.open.append(un)  
            self.closed.append(n)
    
    def link(self, n ,willn):
        willnn = list(willn)
        willnn.front = n
        return willnn

if __name__ == '__main__':
    S0 = [[2,8,3],
         [1,-1,4],
         [7,6,5]]
    S1 = [[1,2,3],
          [8,-1,4],
          [7,6,5]]
    Solution().msearch(S0,S1)
  

代码的一些问题：
1.对于八数码这种状态，可以采用一些常用的压缩策略来减少对内存空间的使用。本文为简单其间，并为采用压缩策略，直接以数组表示。
2.对于查找n的后继节点，应该是可以采用一个循环来减少代码冗余的。
此方法优点，缺点：
1.完备的策略->必定会找到一个解
2.找到的解必定是路径最短的解
3.盲目性大，搜索效率低

为了解决以上，盲目性大，搜索效率低的问题：我们引出A算法。 A算法的原理如下：

A* [1] （A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是许多其他问题的常用启发式算法。注意——是最有效的直接搜索算法，之后涌现了很多预处理算法（如ALT，CH，HL等等），在线查询效率是A*算法的数千甚至上万倍。
公式表示为： f(n)=g(n)+h(n),
其中， f(n) 是从初始状态经由状态n到目标状态的代价估计，
g(n) 是在状态空间中从初始状态到状态n的实际代价，
h(n) 是从状态n到目标状态的最佳路径的估计代价。

**可以看出，A星算法比上述算法的最大的区别，就是多了这个 估价函数f(n) = 实际代价g（n ） + 估计代价h(n) **

A*算法的好处如下：

其实A算法也是一种最好优先的算法
只不过要加上一些约束条件罢了。由于在一些问题求解时，我们希望能够求解出状态空间搜索的最短路径，也就是用最快的方法求解问题，A就是干这种事情的！
我们先下个定义，如果一个估价函数可以找出最短的路径，我们称之为可采纳性。A算法是一个可采纳的最好优先算法。A算法的估价函数可表示为：
f'(n) = g'(n) + h'(n)
这里，f'(n)是估价函数，g'(n)是起点到节点n的最短路径值，h'(n)是n到目标的最短路经的启发值。由于这个f'(n)其实是无法预先知道的，所以我们用前面的估价函数f(n)做近似。g(n)代替g'(n)，但 g(n)>=g'(n)才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h'(n)，但h(n)<=h'(n)才可（这一点特别的重要）。可以证明应用这样的估价函数是可以找到最短路径的，也就是可采纳的。我们说应用这种估价函数的最好优先算法就是A算法。
举一个例子，其实广度优先算法就是A算法的特例。其中g(n)是节点所在的层数，h(n)=0，这种h(n)肯定小于h'(n)，所以由前述可知广度优先算法是一种可采纳的。实际也是。当然它是一种最臭的A*算法。
再说一个问题，就是有关h(n)启发函数的信息性。h(n)的信息性通俗点说其实就是在估计一个节点的值时的约束条件，如果信息越多或约束条件越多则排除的节点就越多，估价函数越好或说这个算法越好。这就是为什么广度优先算法的不甚为好的原因了，因为它的h(n)=0，没有一点启发信息。但在游戏开发中由于实时性的问题，h(n)的信息越多，它的计算量就越大，耗费的时间就越多。就应该适当的减小h(n)的信息，即减小约束条件。但算法的准确性就差了，这里就有一个平衡的问题。

总结下来，其实就是A算法的重点为：在众多的估计代价函数中的最优的即为A(需证明是最优的)

有了以上的一些结论，可以迅速的改改上述代码，得到A*算法：

import time
import copy

class list():
    def __init__(self,info):
        self.info = info
        self.fn = 0   #估价：越小越好
        self.front = None

class Solution():
    def __init__(self):
        self.open = []
        self.closed = []
        self.co = 0
    #A算法的重点：估价函数f(n) = 实际代价g（n ） + 估计代价h(n) 
    #A*算法的重点为：在众多的估计代价函数中的最优的即为A*(需证明是最优的)

    def Asearch(self,S0, Sg):
        head = list(S0)
        head.fn = self.getfn(head,Sg)
        self.open.append(head)
        while self.open:
            #对open表的全部节点按照fn从小到大排序~~~~
            self.open.sort(key=lambda ele:ele.fn)  #默认从小到大
            n = self.open.pop(0)
            self.co += 1
            print('取得节点n:',n.info) 
            if n.info == Sg:
                print('得到问题的解!')
                print('一共进行了',self.co,'次的查找')
                print('该问题的解为：') #对n进行
                while n:
                    print(n.info)
                    n = n.front
                return
            if n in self.closed:
                #节点判定是否为扩展问题
                print('该结点不可扩展') 
            else:
                print('该节点可扩展')
                #扩展节点n，
                #将其子节点放入open的尾部，
                #为每一个子节点设置指向父节点的指针
                nkongdi, nkongdj = 0, 0
                for i in range(3):
                    for j in range(3):
                        if n.info[i][j] == -1:
                            nkongdi = i
                            nkongdj = j
                ln,un,rn,dn =copy.deepcopy(n.info),copy.deepcopy(n.info),copy.deepcopy(n.info),copy.deepcopy(n.info)
                if nkongdj != 0: #right
                    rn[nkongdi][nkongdj],rn[nkongdi][nkongdj-1] = rn[nkongdi][nkongdj-1],rn[nkongdi][nkongdj]
                    rn = self.link(n,rn)
                    if rn not in self.closed:
                        #计算子节点估值～～～
                        rn.fn = self.getfn(rn,Sg)
                        self.open.append(rn)
                if nkongdi != 0: #down
                    dn[nkongdi][nkongdj],dn[nkongdi-1][nkongdj] = dn[nkongdi-1][nkongdj],dn[nkongdi][nkongdj]
                    dn = self.link(n,dn)
                    if dn not in self.closed:
                        dn.fn = self.getfn(dn,Sg)
                        self.open.append(dn)
                if nkongdj != 2: #left
                    ln[nkongdi][nkongdj],ln[nkongdi][nkongdj+1] = ln[nkongdi][nkongdj+1],ln[nkongdi][nkongdj]
                    ln = self.link(n,ln)
                    if ln not in self.closed:
                        ln.fn = self.getfn(ln,Sg)
                        self.open.append(ln)
                if nkongdi != 2: #up
                    un[nkongdi][nkongdj],un[nkongdi+1][nkongdj] =  un[nkongdi+1][nkongdj],un[nkongdi][nkongdj]
                    un = self.link(n,un)
                    if un not in self.closed:
                        un.fn = self.getfn(un,Sg)
                        self.open.append(un)  
            self.closed.append(n)
    
    def link(self, n ,willn):
        willnn = list(willn)
        willnn.front = n
        return willnn

    def h(self, ninfo,Sg):
        #将不再位的A算法和A*算法个数，作为启发信息
        enlight = 0
        for i in range(3):
            for j in range(3):
                if ninfo[i][j] != Sg[i][j]:
                    enlight += 1
        return enlight

    def g(self,n):
        #g(n) = d(n)
        depth = 0
        while n:
            #print(n.info)
            n = n.front
            depth += 1
        return depth
   
    def getfn(self, n ,Sg):
        #传入进的是一个listn
        return self.g(n) + self.h(n.info,Sg)

if __name__ == '__main__':
    S0 = [[2,8,3],
         [1,-1,4],
         [7,6,5]]
    S1 = [[1,2,3],
          [8,-1,4],
          [7,6,5]]
    Solution().Asearch(S0,S1)

可以看出A星算法最为重要的就是启发函数h(n)的选取，h(n)选取的好坏直接关系到了A星算法的好坏。

ps:
A*算法也有一些优化，有兴趣的同学也可以看一下- - ～