八数码问题的Python实现（A算法及A*算法）

最新推荐文章于 2024-09-30 09:15:46 发布
最新推荐文章于 2024-09-30 09:15:46 发布
阅读量1.6w 收藏 113
点赞数 11
分类专栏： Python 文章标签： Python 八数码 A算法 广度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/norstarx/article/details/84255141
版权

一、A算法代码如下：

#! python3
#名称：八数码问题算法
#用途：输入八数码初始状态和预期状态，搜索其解
#节点基本序列：字符0-8，以及字符' '。
#节点数据结构：本节点序列、父节点序列、本节点与目标的偏差、本节点ID、父节点ID
#其中节点ID为全局唯一。
#
#版本：1.0
#更新日期：2018.11.19
#实现方式：采用A算法，广度优先方式
import copy
import os
import time

#将一个八数码序列用3x3的阵列打印出来
def prtNum(src):
    for x in range(3):
        for y in range(3):
            print(str(src[x*3+y]+' '),end='')
        print()

#判断两个数码序列之间的差别，完全相同返回0，有一个字符不相同则返回值+1
def diff(src,dst):
  total=0
  for x in range(len(src)):
    if src[x]!=dst[x]:
      total=total+1
  return total

#返回一个序列中空‘’在序列中的位置，以及在3x3阵列中的行、列位置。
def position(src):
    flag=src.index(' ')
    row=int(flag/3)
    col=int(flag%3)
    return[flag,row,col]

#将一个3x3阵列中两个位置的数值调换，并返回调换后的序列
def exchange(src,x,y,x2,y2):
    flag=x*3+y
    flag2=x2*3+y2
    tmp1=src[flag]
    tmp2=src[flag2]
    dst=copy.copy(src)
    dst[flag]=tmp2
    dst[flag2]=tmp1
    return dst

#用于判定一个序列状态能否变换成另一个序列状态的依据，
#根据理论，转换前后的序列应具有这个特征：假设flag(n)等于
#该序列中数字n前面所有大于它的数字的和，则可以转换的两个序列
#其flag(1)+...+flag(8)之后的奇偶性应该相同。例如，原始状态
#1234 5678的flag()之和为:0, 其可以转换为12345 678，flag()之和
#也为0，因此互相可以转化。
#本函数初始化序列后，返回某个序列的flag（）之和。
#

def judge(number):
        total=0
        data=[9,9,9,9,9,9,9,9,9]
        for i in range(9):
                if number[i]!=' ':
                        data[i]=int(number[i])
                else:
                        data[i]=0
#        print('number is',number)
#        print('data is',data)
        for i in range(9):
                for j in range(i):
                        if data[i] * data[j]!=0:
                                if data[j] > data[i]:
                                        total=total+1
#                print(i,total)
        return total

#用于处理Open表
#方法是：如果Open表非空，则：
#1）按照顺序对open表的每个node中的空格进行所有方向的移动，
#将移动后的新状态节点添加进open表；如果过程中找到了满足条件
#的目的状态节点，则停止处理并返回打印结果；
#如果新获得的序列已存在与open、close表，则不再添加。
#2）将该节点加入close表；
#3）从open表中删除该节点；
#
def handleOpen():
    global nodeid
    global open
    while True:
        if len(open)==0:
                break
#       x=0
        for x in range(len(open)):
          tmp=move(open[x][0],'')
#          print(tmp)
#          print(open)
#          print('tmp length is',len(tmp))
          for y in range(len(tmp)):
                  flag=False
                  for jj in range(len(open)):
#                        print('tmp[y][0]is',tmp[y][0])
#                        print('open[x][0]is',open[x][0])
                        if tmp[y][0]==open[jj][0]:
                                flag=True
#                                print('falg open set to True')
                  for kk in range(len(closed)):
#                         print('tmp[',y,'][0]is',tmp[y][0])
#                         print('closed[',kk,'][0]is',closed[kk][0])
                         if tmp[y][0]==closed[kk][0]:
                                flag=True
#                                print('falg close set to True')
                  if flag==False:
                        open.append([tmp[y][0],tmp[y][1],tmp[y][2],tmp[y][3],open[x][3]])
#                        print('add open node',open[-1])
#                  else:
#                        print('node',tmp[y][0], 'already exists in open or closed!')

                  if tmp[y][2]==0:
                    closed.append(open[x])
                    closed.append(open[-1])
                    open.remove(open[x])
#                    print('add close node',open[x])
                    print('Totally',nodeid,'nodes ayalyzed,find the result.')
                    prtResult()
                    print('Success!')
                    exit("We find it!")
          closed.append(open[x])
#          print('add close node',open[x])
          open.remove(open[x])
          
#基于输入的序列进行移动，并返回所有可能的移动后目的序列；
#每条数据：节点序列、前一节点序列、与目标序列偏差值、当前节点序列ID
def move(src,side):
    global crt
    global nodeid
    pos=position(src)
    flag=pos[0]
    x=pos[1]
    y=pos[2]
    leftDiff=999
    rightDiff=999
    upDiff=999
    downDiff=999
#    print('Node being analyzed is:')
#    prtNum(src)
    rtResult=[]
    if side=='left' or side=='':
      if y>0:
        crtLeft=exchange(src,x,y,x,y-1)
#        print('Can move to LEFT,after move result is:')
#        prtNum(crtLeft)
        leftDiff=diff(numberFinal,crtLeft)
#        print('different factor is',leftDiff)
#        addOpen(crtLeft,src,leftDiff)
#        return [crtLeft,src,leftDiff]
        nodeid=nodeid+1
        rtResult.append([crtLeft,src,leftDiff,nodeid])
#      else:
#        print('Cannot move to LEFT!')

    if side=='right' or side=='':
      if y<2:
        crtRight=exchange(src,x,y,x,y+1)
#        print('Can move to Right,after move result is:')
#        prtNum(crtRight)
        rightDiff=diff(numberFinal,crtRight)
#        print('different factor is',rightDiff)
#        return(crtRight,src,rightDiff)
        nodeid=nodeid+1
        rtResult.append([crtRight,src,rightDiff,nodeid])
#      else:
#        print('Cannot move to RIGHT!')

    if side=='up' or side=='':
      if x>0:
#        print('Can move to UP,after move result is:')
        crtUp=exchange(src,x,y,x-1,y)
#        prtNum(crtUp)
        upDiff=diff(numberFinal,crtUp)
#        print('different factor is',upDiff)
#        return(crtUp,src,upDiff)
        nodeid=nodeid+1
        rtResult.append([crtUp,src,upDiff,nodeid])
#      else:
#        print('Cannot move to UP!')

    if side=='down' or side=='':
      if x<2:
#        print('Can move to DOWN,after move result is:')
        crtDown=exchange(src,x,y,x+1,y)
#        prtNum(crtDown)
        downDiff=diff(numberFinal,crtDown)
#        print('different factor is',downDiff)
#        return(crtDown,src,downDiff)
        nodeid=nodeid+1
        rtResult.append([crtDown,src,downDiff,nodeid])
#      else:
#        print('Cannot move to DOWN!')
    if nodeid%1000>=0 and nodeid%1000 < 3:
            print(int(nodeid/1000)*1000,'nodes analyzed!')
    return rtResult

#打印结果，方法是从close表最后一条开始，查找其前一个节点，
#直到前一节点为0，并将所有查到的序列写入step，打印出step
#即得到所有的变化过程。
def prtResult():
      step=[closed[-1]]
      nodePrt=closed[-1][4]
      while True:
            for x in range(len(closed)):
                  if nodePrt==closed[x][3]:
                        step.insert(0,closed[x])
                        nodePrt=closed[x][4]
            if nodePrt==0:
                  break            
      for x in range(len(step)):
            print('Step',x,':')
            prtNum(step[x][0])
      print('Finished!')
      time.sleep(10)
            
#numberOrig=['1','2','3','4','7',' ','6','5','8']

#numberOrig=[' ','7','2','5','1','6','8','3','4']

#numberOrig=['4','1','6','7','2','8','5',' ','3']

#numberFinal=['1','2','3','4','5','6','7','8',' ']

open=[]

closed=[]

nodeid=1


#主程序
#输入初始和目标序列，并打印出来供确认，如不正确可重新输入
while True:
        print('Please input Original state:',end='\t')
        tmp=input()
        numberOrig=[tmp[0],tmp[1],tmp[2],tmp[3],tmp[4],tmp[5],tmp[6],tmp[7],tmp[8]]
        print('Please input Final state:',end='\t')
        tmp=input()
        numberFinal=[tmp[0],tmp[1],tmp[2],tmp[3],tmp[4],tmp[5],tmp[6],tmp[7],tmp[8]]
        print('Orig is')
        prtNum(numberOrig)
#        print('Orig judge is',judge(numberOrig))
        print('Final is')
        prtNum(numberFinal)
#        print('Final judge is',judge(numberFinal))
        print('Is it correct?',end='\t')
        confirm=input()
        if confirm=='y':
              break
#如果初始和目标序列的判定值奇偶性一致，则存在解，开始处理
if (judge(numberOrig)+judge(numberFinal))%2==0:
        print('Have answer! Orig is ',judge(numberOrig),', Final is',judge(numberFinal))
#处理方式：将初始节点加入open表，开始处理。
        open.append([numberOrig,'NULL',diff(numberOrig,numberFinal),1,0])
        handleOpen()
#否则，不存在解，直接退出。
else:
        print('No answer! Orig is ',judge(numberOrig),', Final is',judge(numberFinal))

二、运行示意如下：

1、无解的情况：

Please input Original state:    1234 5678
Please input Final state:    123 45687
Orig is
1 2 3
4   5
6 7 8
Final is
1 2 3
  4 5
6 8 7
Is it correct?    y
No answer! Orig is  0 , Final is 1

2、有解的情况：

====================== RESTART: C:\Python34\bashuma.py ======================
Please input Original state:    1234 5678
Please input Final state:    12 345678
Orig is
1 2 3
4   5
6 7 8
Final is
1 2   
3 4 5
6 7 8
Is it correct?    y
Have answer! Orig is  0 , Final is 0
1000 nodes analyzed!
2000 nodes analyzed!
2000 nodes analyzed!
3000 nodes analyzed!
4000 nodes analyzed!
5000 nodes analyzed!
6000 nodes analyzed!
7000 nodes analyzed!
Totally 7440 nodes ayalyzed,find the result.
Step 0 :
1 2 3
4   5
6 7 8
Step 1 :
1 2 3
  4 5
6 7 8
Step 2 :
  2 3
1 4 5
6 7 8
Step 3 :
2   3
1 4 5
6 7 8
Step 4 :
2 3   
1 4 5
6 7 8
Step 5 :
2 3 5
1 4   
6 7 8
Step 6 :
2 3 5
1   4
6 7 8
Step 7 :
2   5
1 3 4
6 7 8
Step 8 :
  2 5
1 3 4
6 7 8
Step 9 :
1 2 5
  3 4
6 7 8
Step 10 :
1 2 5
3   4
6 7 8
Step 11 :
1 2 5
3 4   
6 7 8
Step 12 :
1 2   
3 4 5
6 7 8
Finished!
Success!
>>>

三、改进：A*算法的实现
A*算法，实际是在将新节点插入open表时，按照估值函数的大小，将更优的节点插入到更靠前的位置。
在A算法的基础上，做少量修改即可。
1、增加addOpen函数
#V1.1 新增，用于将新的节点按照判定值（diff值）插入现有open表
#判定值小的node靠前
def addOpen(node):
        if len(open)==0 or node[2]>=open[-1][2]:
            open.append(node)
#            print('append open',node)
        else:
            for i in range(len(open)):
                if node[2]<open[i][2]:
                    open.insert(i,node)
                    break

2、在handleOpen()中做适当修改即可，handleOpen函数修改为如下内容：

def handleOpen():
    global nodeid
    global open
    while True:
          if len(open)==0:
                break
#v1.1修改
          x=0
#        for x in range(len(open)):
          tmpOpen=open[0]
          
          tmp=move(open[0][0],'')
#          print(tmp)
#          print(open)
#          print('tmp length is',len(tmp))
          for y in range(len(tmp)):
                  flag=False
                  for jj in range(len(open)):
#                        print('tmp[y][0]is',tmp[y][0])
#                        print('open[x][0]is',open[x][0])
                        if tmp[y][0]==open[jj][0]:
                                flag=True
#                                print('falg open set to True')
                  for kk in range(len(closed)):
#                         print('tmp[',y,'][0]is',tmp[y][0])
#                         print('closed[',kk,'][0]is',closed[kk][0])
                         if tmp[y][0]==closed[kk][0]:
                                flag=True
#                                print('falg close set to True')
                  if flag==False:

#V1.1 修改
#                        open.append([tmp[y][0],tmp[y][1],tmp[y][2],tmp[y][3],open[x][3]])
                         addOpen([tmp[y][0],tmp[y][1],tmp[y][2],tmp[y][3],open[x][3]])

#                        print('add open node',open[-1])
#                  else:
#                        print('node',tmp[y][0], 'already exists in open or closed!')

                  if tmp[y][2]==0:
#V1.0
#                    closed.append(open[x])
#                    closed.append(open[-1])
#                    open.remove(open[x])
#                    print('add close node',open[x])
#V1.1
                    closed.append(tmpOpen)
                    closed.append(open[0])
                    open.remove(open[0])
#                    print('add close node',open[x])

                    print('Totally',nodeid,'nodes ayalyzed,find the result.')
                    prtResult()
                    print('Success!')
                    exit("We find it!")
#V1.0          closed.append(open[x])
#V1.1
          closed.append(tmpOpen)
#          print('add close node',open[x])
#v1.0      open.remove(open[x])
#V1.1
          open.remove(tmpOpen)

对比：A*算法后者可大大提高计算效率和速度，以原始状态1234 5678，目标状态8765 4321为例，
A*算法通过分析5028个节点，很快可得到结果（转换需要72步，如下），但A算法分析10万个以上的节点也无法得到结果。
Please input Original state:    1234 5678
Please input Final state:    8765 4321
Orig is
1 2 3
4   5
6 7 8
Final is
8 7 6
5   4
3 2 1
Is it correct?    y
Have answer! Orig is  0 , Final is 28
1000 nodes analyzed!
1000 nodes analyzed!
2000 nodes analyzed!
3000 nodes analyzed!
4000 nodes analyzed!
5000 nodes analyzed!
Totally 5028 nodes ayalyzed,find the result.
Step 0 :
1 2 3
4   5
6 7 8
Step 1 :
1 2 3
  4 5
6 7 8
Step 2 :
  2 3
1 4 5
6 7 8
Step 3 :
2   3
1 4 5
6 7 8
Step 4 :
2 3   
1 4 5
6 7 8
Step 5 :
2 3 5
1 4   
6 7 8
Step 6 :
2 3 5
1   4
6 7 8
Step 7 :
2   5
1 3 4
6 7 8
Step 8 :
  2 5
1 3 4
6 7 8
Step 9 :
1 2 5
  3 4
6 7 8
Step 10 :
1 2 5
3   4
6 7 8
Step 11 :
1 2 5
3 7 4
6   8
Step 12 :
1 2 5
3 7 4
  6 8
Step 13 :
1 2 5
  7 4
3 6 8
Step 14 :
1 2 5
7   4
3 6 8
Step 15 :
  2 5
1 7 4
3 6 8
Step 16 :
2   5
1 7 4
3 6 8
Step 17 :
2 7 5
1   4
3 6 8
Step 18 :
2 7 5
1 6 4
3   8
Step 19 :
2 7 5
1 6 4
3 8   
Step 20 :
2 7 5
1 6   
3 8 4
Step 21 :
2 7 5
1   6
3 8 4
Step 22 :
2   5
1 7 6
3 8 4
Step 23 :
2 5   
1 7 6
3 8 4
Step 24 :
2 5 6
1 7   
3 8 4
Step 25 :
2 5 6
1   7
3 8 4
Step 26 :
2 5 6
1 7 4
3 8   
Step 27 :
2 5 6
1 7 4
3   8
Step 28 :
2 5 6
1   4
3 7 8
Step 29 :
2 5 6
  1 4
3 7 8
Step 30 :
  5 6
2 1 4
3 7 8
Step 31 :
5   6
2 1 4
3 7 8
Step 32 :
5 1 6
2   4
3 7 8
Step 33 :
5 1 6
2 7 4
3   8
Step 34 :
5 1 6
2 7 4
  3 8
Step 35 :
5 1 6
  7 4
2 3 8
Step 36 :
5 1 6
7   4
2 3 8
Step 37 :
  1 6
5 7 4
2 3 8
Step 38 :
1   6
5 7 4
2 3 8
Step 39 :
1 7 6
5   4
2 3 8
Step 40 :
1 7 6
5 3 4
2   8
Step 41 :
1 7 6
5 3 4
  2 8
Step 42 :
1 7 6
5 3 4
2 8   
Step 43 :
1 7 6
5 3   
2 8 4
Step 44 :
1 7 6
5   3
2 8 4
Step 45 :
1 7 6
5 8 3
2   4
Step 46 :
1 7 6
5 8 3
  2 4
Step 47 :
1 7 6
  8 3
5 2 4
Step 48 :
1 7 6
8   3
5 2 4
Step 49 :
1   6
8 7 3
5 2 4
Step 50 :
  1 6
8 7 3
5 2 4
Step 51 :
8 1 6
  7 3
5 2 4
Step 52 :
8 1 6
7   3
5 2 4
Step 53 :
8 1 6
7 3   
5 2 4
Step 54 :
8 1 6
7 3 4
5 2   
Step 55 :
8 1 6
7 3 4
5   2
Step 56 :
8 1 6
7   4
5 3 2
Step 57 :
8 1 6
  7 4
5 3 2
Step 58 :
8 1 6
5 7 4
  3 2
Step 59 :
8 1 6
5 7 4
3   2
Step 60 :
8 1 6
5 7 4
3 2   
Step 61 :
8 1 6
5   4
3 7 2
Step 62 :
8   6
5 1 4
3 7 2
Step 63 :
8 6   
5 1 4
3 7 2
Step 64 :
8 6 4
5 1   
3 7 2
Step 65 :
8 6 4
5   1
3 7 2
Step 66 :
8 6 4
5 7 1
3   2
Step 67 :
8 6 4
5 7 1
3 2   
Step 68 :
8 6 4
5 7   
3 2 1
Step 69 :
8 6 4
5   7
3 2 1
Step 70 :
8 6   
5 7 4
3 2 1
Step 71 :
8   6
5 7 4
3 2 1
Step 72 :
8 7 6
5   4
3 2 1
Finished!
Success!

norstarx
关注
专栏目录
八数码问题（8皇后问题）的A*算法求解（Python实现）
06-03
主要实现了A*算法解决8数码问题，另有深度优先，广度优先及有序搜索的实现
A*算法解决8数码问题（Python实现）
12-28
算法课程实验、大作业
A*算法解决八数块问题——python
m0_68812689的博客
08-24 243
【代码】A*算法解决八数块问题——python。
python 实现A-Star算法
最新发布
luthane的博客
09-30 1098
A-Star（A*）算法是一种广泛使用的启发式搜索算法，用于在图形平面或网络中找到从起点到终点的最短路径。它结合了Best-First Search算法和Dijkstra算法的特点，通过使用启发函数来指导搜索过程，从而提高搜索效率。A算法的基本原理g(n)：从起点到当前节点n的实际代价。h(n)：从当前节点n到目标节点的估计代价。这两个值被用来计算f(n)fngnhnfngnhn。
【Python】A*八数码问题_求解思路与代码实现
I_no_know_answer的博客
05-21 2189
A*八数码，求解思路与代码实现
A*算法python实现
read, note and comment papers
03-19 437
【代码】A*算法python实现。
用python实现a 算法_A*算法与其python实现
weixin_40009099的博客
12-10 399
#需要进行抽象化的有：节点(属性有：x y坐标 父节点 g及h ) 地图(属性有高度 宽度 数据(数据中有可通行路径与障碍两种))#A_star :# open_list (存放待测试的点，刚开始有start加入list，后面每一个current的相邻点(不能位于colse_list中且不是终点)要放到open_list中) 表示已经走过的点# close_list(存放已测试的点，已经当...
基于Python的A*算法解决八数码问题
qbx的博客
04-21 2460
定义一个State类，主要用于表示搜索过程中的状态结点，包括结点的代价和状态信息，以及结点之间的关系。属性：gn：从起始结点到当前结点的实际代价。hn：从当前结点到目标结点的估计代价（启发式函数）。fn：综合代价，即gn+hn。child：子结点列表，存储从当前结点可以到达的所有子结点。par：父结点，指向生成当前结点的父结点。state：当前结点的状态矩阵。hash_value：当前结点状态矩阵的哈希值，用于在查找表中快速查找。方法：__lt__：小于运算符重载，用于结点比较。
【AI】Python 实现八数码问题
Elford的博客
12-04 6085
八数码问题
人工智能-A*启发式搜索算法解决八数码问题 Python实现
热门推荐
SCY164759920的博客
10-04 2万+
八数码问题也称为九宫问题。在 3×3 的棋盘，摆有八个棋子，每个棋子上标有 1 至 8 的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格（以数字 0 来表示），与空 格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。该问题可用A*启发式搜索算法求解。
八数码难题——Python代码求解
04-14
该资源包用了BFS，DFS，一直代价，贪婪，A*算法求解八数码难题。其中包括一个设计UI界面的代码，实现了问题解决过程的可视化。
Python 八数码问题，可以直接运行
05-03
Python 八数码问题，如果使用Spyder，可以直接运行，其他需要导入相应包
python版的八数码与N皇后
11-26
这是python版本的八数码与N皇后实现，我写的，看不明白请骂我！！！
eightPuzzle_BFS_八数码python_八数码问题_源码.zip
10-25
eightPuzzle_BFS_八数码python_八数码问题_源码
Python利用A算法解决八数码问题.zip
10-20
资源包含文件：课程报告word+源码 利用A*算法解决八数码问题，比较不同启发函数（h1，h2）的搜索效率，并验证关于A*算法的命题。详细介绍参考：https://blog.csdn.net/sheziqiong/article/details/126052182
A*算法解决八数码问题 python实现
05-07
A*算法解决八数码问题 python代码可跑
python -A*算法
博咯的博客
12-07 4048
A*算法前言一、A*算法实现步骤二、python代码1.，地图及移动成本2.设置列表等数据3.设置子节点4.初始化起点和终点坐标及地图大小5.初始化父坐标6.将起点加入到open列表中7.从open列表最小F节点，存入close列表中8. 获取子节点9.PK已存在路径和当前路径，选择最优10.获取最终路径11. 主程序-任务执行总结 前言 A算法是一种静态网中最短路径最有效的直接搜索方法。多用于游戏和物流中的路径规划问题。 A算法的详细解读可以看iwiniwin —http://www.cnblogs.co
python---A*搜索算法解决八数码问题
via CHEng的博客
04-30 1万+
A*解决八数码问题
Python利用A*算法解决八数码问题
毕业作品网站
07-29 5483
利用 A算法解决八数码问题，比较不同启发函数（h1，h2）的搜索效率，并验证关于 A算法的命题。
八数码问题a*算法python
06-12
八数码问题是一种经典的搜索问题，可以使用 A* 算法来求解。A* 算法是一种启发式搜索算法，可以在保证搜索最优解的同时尽可能减少搜索的时间和空间成本。下面是一个使用 Python 实现的八数码问题 A* 算法的示例代码： ``` from queue import PriorityQueue class Puzzle: def __init__(self, board): self.board = board self.moves = [] self.cost = 0 def get_distance(self, target_board): distance = 0 for i in range(3): for j in range(3): value = self.board[i][j] if value != 0 and value != target_board[i][j]: target_i, target_j = divmod(value - 1, 3) distance += abs(i - target_i) + abs(j - target_j) return distance def get_next_puzzles(self): next_puzzles = [] i, j = next((i, j) for i in range(3) for j in range(3) if self.board[i][j] == 0) for di, dj in [(0, 1), (0, -1), (1, 0), (-1, 0)]: if 0 <= i + di < 3 and 0 <= j + dj < 3: next_board = [row[:] for row in self.board] next_board[i][j], next_board[i + di][j + dj] = next_board[i + di][j + dj], next_board[i][j] next_puzzle = Puzzle(next_board) next_puzzle.moves = self.moves + [(i + di, j + dj)] next_puzzle.cost = len(next_puzzle.moves) + next_puzzle.get_distance(target_board) next_puzzles.append(next_puzzle) return next_puzzles def __lt__(self, other): return self.cost < other.cost def solve_puzzle(start_board, target_board): start_puzzle = Puzzle(start_board) start_puzzle.cost = start_puzzle.get_distance(target_board) queue = PriorityQueue() queue.put(start_puzzle) visited = set() while not queue.empty(): puzzle = queue.get() if puzzle.board == target_board: return puzzle.moves for next_puzzle in puzzle.get_next_puzzles(): if tuple(map(tuple, next_puzzle.board)) not in visited: visited.add(tuple(map(tuple, next_puzzle.board))) queue.put(next_puzzle) return None start_board = [[1, 2, 3], [4, 5, 6], [7, 8, 0]] target_board = [[1, 2, 3], [4, 5, 6], [7, 0, 8]] moves = solve_puzzle(start_board, target_board) if moves: for move in moves: print(move) else: print("No solution found.") ``` 在这个示例代码中，我们首先定义了一个 `Puzzle` 类来表示每个状态，其中包含了当前的棋盘状态以及移动序列和代价（即移动序列的长度加上当前状态到目标状态的估计距离）。然后我们使用 A* 算法来搜索最优解，其中使用了一个优先队列来进行状态的扩展，以保证每次扩展的状态都是代价最小的。最后，我们输出找到的移动序列，或者在无解的情况下输出提示信息。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值