回溯法解決八數碼問題python

這次人工智能的作業就是用回溯法解決八數碼問題，經過一天多的功夫，終於寫出來了。下面是正題

回溯法是人工智能領域的一種重要的盲目搜索算法，何爲盲目算法，即是基於規則，不斷的嘗試可能的路徑，直到到達目的的解爲止。
回溯法（探索與回溯法）是一種選優搜索法，又稱爲試探法，按選優條件向前搜索，以達到目標。但當探索到某一步時，發現原先選擇並不優或達不到目標，就退回一步重新選擇，這種走不通就退回再走的技術爲回溯法，而滿足回溯條件的某個狀態的點稱爲“回溯點”。
回溯法一般需要三張表
ps表：用於保存當前路徑的狀態，如果找到目標狀態，ps就是解題路徑上的狀態有序集。
nps表：新的路徑狀態表。它包含了等待搜索的狀態，其後裔狀態還未被搜索到即未生成擴展。
nss表：不可解狀態集，列出了找不到解題路徑的狀態，如果在搜索中擴展出的狀態是該表的元素，則將該狀態排除。
此外，八數碼還有一個書否有解的條件，即初始狀態和目標狀態的逆序數奇偶性相同。
逆序數：一個狀態表示成一維的形式，求出除0之外所有數字的逆序數之和，也就是每個數字前面比它大的數字的個數的和，稱爲這個狀態的逆序。
回溯法搜索過程示意圖如下所示：

其搜索起點爲A初始值：ps=[A], nps=[A],nss=[]，目標點爲G

0	搜索點	ps	nps	nss
1	A	[A]	[A]	[ ]
2	B	[BA]	[BCDA]	[ ]
3	E	[EBA]	[EFBCDA]	[ ]
4	I	[IJEBA]	[IJEFBCD]	[ ]
5	J	[JEBA]	[JEFBCDA]	[I]
6	F	[FBA]	[FBCDA]	[EJI]
7	K	[KFBA]	[KFBCDA]	[EJI]
8	C	[CA]	[CDA]	[BFKEJI]
9	G	[GCA]	[GHCDA]	[BFKEJI]

在搜索過程中，先進行深度搜索，直到到達指點深度，或者不可解點返回，並將該狀態置爲不可解點，然後回到上一節點進行擴展。直到找到結果或者搜完所有深度爲止。
回溯法實現八數碼思路亦是如此
初始狀態 :
2 8 3
1 6 4
7 0 5

目標狀態:
1 2 3
8 0 4
7 6 5

下面是python代碼,數碼的狀態用一維數組表示
節點狀態類Node.py

#encoding:utf-8
from Node import *
class back:
    def __init__(self,orignate,target,length):
        self.origate=orignate  #初始狀態
        self.target=target  #目標狀態
        self.ps=[]  #PS表，用於保存當前搜索路徑的狀態
        self.nps=[] #nps表，用於保存等待搜索的狀態
        self.nss=[] #nss表，用於保存不可到達目的地的狀態集
        self.spce=[-3,3,-1,1] #上下左右四個移動方向
        self.length=length
        self.MaxDegree=5  #深度限制，到達此深度回溯

    def issolve(self): #判斷到目標狀態是否有解
        targetVer=self.getreVersNum(self.target.state)
        orinateVer=self.getreVersNum(self.origate.state)
        if(targetVer%2!=orinateVer%2):
            return False
        else:
            return True



    def getreVersNum(self,state):  #獲取逆序數
        sum=0
        for i in range(0,len(state)):
            if(state[i]==0):
                continue
            else:
                for j in range(0,i):
                    if(state[j]>state[i]):
                        sum+=1

        return sum

    # def getspaceIndex(self): #獲得空格所在的位置
    #     for i in range(len(self.origate)-1):
    #         if(self.origate[i]==0):
    #             return i

    def copyArray(self,state):
        arr=[]
        return arr+state


    #判斷狀態數碼是否存在
    def isexit(self,node,table):
        for i in table:
            if(i.state==node.state):
                return True
        return False




    #主要算法，回溯過程
    def backMainProcess(self):
        self.ps.append(self.origate)
        self.nps.append(self.origate)
        while(len(self.nps)):
            originateState=self.ps[-1]

            spacIndex=originateState.state.index(0)
            if(originateState.state==self.target.state):
                return True
            else:

                #到達指定深度，回溯
                if(originateState.degree>=self.MaxDegree):


                    self.ps.pop()
                    self.nps.pop()
                    if(self.nps[-1]!=self.ps[-1]):

                      self.ps.append(self.nps[-1])
                    self.nss.insert(0,originateState)
                    continue
                flag=False
                for i in range(len(self.spce)):

                    if((i==0 and (spacIndex+self.spce[i])>=0) or
                    (i==1 and (spacIndex+self.spce[i])<len(self.target.state)-1)
                    or(i==2 and (spacIndex%self.length!=0 )) or
                    (i==3 and ((spacIndex+1)%self.length)!=0)):
                        state=self.copyArray(originateState.state)
                        #擴展狀態
                        temp=state[spacIndex+self.spce[i]]
                        state[spacIndex+self.spce[i]]=0
                        state[spacIndex]=temp
                        #判斷新的狀態是否已經存在
                        nodeState=Node(state,originateState.degree+1)

                        if(self.isexit(nodeState,self.nps))or (self.isexit(nodeState,self.nss)):
                            continue
                        else:
                            flag=True

                            self.nps.append(nodeState)
                if(not flag):

                    self.ps.pop()
                    self.nps.pop()
                    if(self.nps[-1]!=self.ps[-1]):
                      self.ps.append(self.nps[-1])
                    self.nss.append(originateState)
                if(flag):#展開有子節點
                    self.ps.append(self.nps[-1])
    #輸出結果路徑
    def showLine(self):
        for node in self.ps:
            i=0
            print(node.state[i],node.state[i+1],node.state[i+2])
            print(node.state[i+3],node.state[i+4],node.state[i+5])
            print(node.state[i+6],node.state[i+7],node.state[i+8])
            print('->:')








if __name__ == '__main__':


    originate=[2,8,3,1,6,4,7,0,5]
    target=[1,2,3,8,0,4,7,6,5]
    node1=Node(originate,0)
    node2=Node(target,0)
    c=back(node1,node2,3)
    if(c.issolve()):
        if(c.backMainProcess()):
            print('已找到解！！！！,路徑如下')
            c.showLine()
    else:
        print('此過程無解')

運行結果：

已找到解！！！！,路徑如下
(2, 8, 3)
(1, 6, 4)
(7, 0, 5)
->:
(2, 8, 3)
(1, 0, 4)
(7, 6, 5)
->:
(2, 0, 3)
(1, 8, 4)
(7, 6, 5)
->:
(0, 2, 3)
(1, 8, 4)
(7, 6, 5)
->:
(1, 2, 3)
(0, 8, 4)
(7, 6, 5)
->:
(1, 2, 3)
(8, 0, 4)
(7, 6, 5)
->: