Python实现用BFS、DFS和A*算法解决8数码问题

最新推荐文章于 2024-05-21 17:59:18 发布
最新推荐文章于 2024-05-21 17:59:18 发布
阅读量1.2w 收藏 257
点赞数 41
分类专栏： 人工智能实验 文章标签： python bfs dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ning_Y_N/article/details/113100178
版权

作为小白的我写这篇博客的时候内心瑟瑟发抖，表达文案能力有限，以下是我对8数码问题的一下小见解，如内容有错误，请在评论区讨论（最好改正并告知我），请大家多多包涵。

思路参考博客：https://blog.csdn.net/u013300280/article/details/106234521

8数码问题：

8数码问题又称九宫格问题，在3x3的棋盘上，问题的解决是移动空格使得8数码从初始状态到目标状态。

8数码是否有解
判断8数码逆序的奇偶性
若两个状态的逆序奇偶性相同，则可相互到达，否则不可相互到达
可以参考：https://blog.csdn.net/hnust_xiehonghao/article/details/7951173

BFS（宽度优先搜索）：

其基本思想是优先搜索当前顶点的所有邻接结点。
基本步骤：
①建立只含有初始节点S的搜索图G，把S放到open表中；
②建立closed表，其初始值为空表；
③若open表是空表，则失败退出；
④选择open表中第一个节点，把它从open表移出并放进closed表中，称此节点为当前节点；
⑤若当前节点为目标节点，则有解并成功退出。
⑥扩展当前节点，并把子节点放到open表的后面。

代码：

'''
author:Ning_Y_N
date:2020-10-27
'''
import random  # 引入导包

#修改索引，方便接下来交换
def move(str,index):
    if str=='up':
        return index-3
    if str=='dowm':
        return index+3
    if str=='left':
        return  index-1
    if str=='right':
        return index+1

#生成新的结点并且记录路径
def path(array1,array2):
    p=array1[:]
    p.insert(0,array2)
    for i in close:
        if i[0] == p[0]:
             return False
    open.append(p)
    return True

#打印
def out(list):
    for j in range(len(list)):
        if j % 3 == 0:
            print('\t')
        print(list[j], end=' ')
    print('\t')

#判断8数码逆序的奇偶性
#若两个状态的逆序奇偶性相同，则可相互到达，否则不可相互到达
def issolution(array):
    num = 0
    for i in range(len(array) - 1):
        for j in range(i + 1, len(array)):
            if array[i] == 0 or array[j] == 0:
                continue
            if array[i] < array[j]:
                num += 1
    return num%2

'''
#随机生成初始状态
def rand(list):
    a = random.randint(0, 8)
    list.append(a)
    for i in range(8):
        i = random.randint(0, 8)
        while 1:
            if i not in list:
                list.append(i)
                break
            else:
                i = random.randint(0, 8)
'''
if __name__=="__main__":
    #start=[]
    #rand(start)
    # orgin=input(">>").split()    #自行输出8数码初始状态
    # start=[int(x) for x in orgin]
    start=[2,8,3,1,6,4,7,0,5]
    #start = [2, 8, 3, 1, 0, 4, 7, 6, 5]
    goal = [1, 2, 3, 8, 0, 4, 7, 6, 5]
    #如果初态和终态的逆序奇偶性不同则无解
    if issolution(start) != issolution(goal):
        print('该始末状态的8数码无解')
        exit()
    open=[]
    close=[]
    creatp=serchp=step=0
    open.append([start])
    while 1:
        if start==goal:
            print('初始状态即为解!')
            break
        if len(open)==0:
            print('未找到解')
            break
        else:
            this=open.pop(0)
            #print(this)
            if len(this)>9*8*7*6*5*4*3*2:
                break
            serchp+=1
            close.append(this)
            #print(close)
            if this[0]==goal:
                print('搜索成功')
                print('共创建{}个结点，共搜索{}个结点,共{}步'.format(creatp,serchp,len(this)-1))
                for i in this[::-1]:
                    out(i)
                exit()

            #上，下，左，右扩展结点

            if this[0].index(0)>2 :
                node=this[0].copy()
                a=this[0].index(0)
                b=move('up',a)
                node[a],node[b]=node[b],node[a]
                path(this, node)
                creatp += 1

            if this[0].index(0) < 6 :
                node = this[0].copy()
                a = this[0].index(0)
                b = move('dowm', a)
                node[a],node[b]=node[b],node[a]
                path(this, node)
                creatp += 1


            if this[0].index(0) != 0 and this[0].index(0) != 3 and this[0].index(0) != 6:
                node = this[0].copy()
                a = this[0].index(0)
                b = move('left', a)
                node[a],node[b]=node[b],node[a]
                path(this, node)
                creatp+= 1


            if this[0].index(0) != 2 and this[0].index(0) != 5 and this[0].index(0) != 8:
                node = this[0].copy()
                a = this[0].index(0)
                b = move('right', a)
                node[a],node[b]=node[b],node[a]
                path(this, node)
                creatp += 1

示例截图：

在这里插入图片描述

DFS（深度优先搜索）：

基本步骤：
①建立只含有初始节点S的搜索图G，把S放到open表中；
②建立closed表，其初始值为空表；
③若open表是空表，则失败退出；
④选择open表中第一个节点，把它从open表移出并放进closed表中，称此节点为当前节点；
⑤若当前节点为目标节点，则有解并成功退出。
⑥扩展当前节点，并把子节点放到open表的前面。

代码：

'''
author:Ning_Y_N
date:2020-10-27
'''
import random  # 引入导包

#返回索引，方便接下来交换
def move(str,index):
    if str=='up':
        return index-3
    if str=='dowm':
        return index+3
    if str=='left':
        return  index-1
    if str=='right':
        return index+1

#生成新的结点并且记录路径
def path(array1,array2):
    p=array1[:]
    p.insert(0,array2)
    for i in close:
        if i[0] == p[0]:
            return False
    open.insert(0,p)
    return True

#打印
def out(list):
    for j in range(len(list)):
        if j % 3 == 0:
            print('\t')
        print(list[j], end=' ')
    print('\t')

def issolution(array):
    num = 0
    for i in range(len(array) - 1):
        for j in range(i + 1, len(array)):
            if array[i] == 0 or array[j] == 0:
                continue
            if array[i] < array[j]:
                num += 1
    return num%2

'''
def rand(list):
    a = random.randint(0, 8)
    list.append(a)
    for i in range(8):
        i = random.randint(0, 8)
        while 1:
            if i not in list:
                list.append(i)
                break
            else:
                i = random.randint(0, 8)
'''

if __name__=="__main__":
    # start=[]
    # rand(start)
    # orgin=input(">>").split()
    # start=[int(x) for x in orgin]
    # 如果初态和终态的逆序奇偶性不同则无解
    start=[2,8,3,1,6,4,7,0,5]
    #start=[2,8,3,1,0,4,7,6,5]
    goal=[1,2,3,8,0,4,7,6,5]
    if issolution(start) != issolution(goal):
        print('该始末状态的8数码无解')
        exit()
    open=[]
    close=[]
    creatp=serchp=step=0
    open.append([start])
    while 1:
        if start==goal:
            print('初始状态即为解!')
            break
        if len(open)==0:
            print('未找到解')
            break
        else:
            this=open.pop(0)
            #print(this)
            serchp+=1
            close.append(this)
            if this[0]==goal:
                print('搜索成功')
                print('共创建{}个结点，共搜索{}个结点,共{}步'.format(creatp,serchp,len(this)-1))
                for i in this[::-1]:
                    out(i)
                exit()

            #上，下，左，右
            if this[0].index(0)>2 :
                node=this[0].copy()
                a=this[0].index(0)
                b=move('up',a)
                node[a],node[b]=node[b],node[a]
                path(this, node)
                creatp += 1

            if this[0].index(0) < 6 :
                node = this[0].copy()
                a = this[0].index(0)
                b = move('dowm', a)
                node[a],node[b]=node[b],node[a]
                path(this, node)
                creatp += 1

            if this[0].index(0) != 0 and this[0].index(0) != 3 and this[0].index(0) != 6:
                node = this[0].copy()
                a = this[0].index(0)
                b = move('left', a)
                node[a],node[b]=node[b],node[a]
                path(this, node)
                creatp += 1

            if this[0].index(0) != 2 and this[0].index(0) != 5 and this[0].index(0) != 8:
                node = this[0].copy()
                a = this[0].index(0)
                b = move('right', a)
                node[a],node[b]=node[b],node[a]
                path(this, node)
                creatp += 1

截图：

在这里插入图片描述
…
在这里插入图片描述

A*算法：

1、A算法的基本原理分析；
在搜索过程的步骤中，加入估价函数f(n)=g(n)+h(n)对open表中的节点进行排序，则该搜索算法为A*算法。
g(n)：从初始节点到当前节点的层数。
h(n)：启发函数，当前节点对比目标节，错误数字的个数（可能使用错误位置的曼哈顿位置会更好些）。

我此处使用的估计函数是f(n)=h(n)，h(n)在此处是当前状态与目标状态数字相同的个数，并且我以相同个数最多的排序在最前面。（即错误数字个数最少的反面）

代码：

'''
author:Ning_Y_N
date:2020-10-27
'''
import random
#修改索引，方便接下来交换
def move(str,index):
    if str=='up':
        return index-3
    if str=='dowm':
        return index+3
    if str=='left':
        return  index-1
    if str=='right':
        return index+1

#生成新的结点并且记录路径
def create(array1,array2):
    p=array1[:]
    p.insert(0,array2)
    for i in close:
        if i[0] == p[0]:
            return False
    open.append(p)
    return True

#打印
def show(list):
    for j in range(len(list)):
        if j % 3 == 0:
            print('\t')
        print(list[j], end=' ')
    print('\t')

#估计函数，与目标结点对比，返回当前数码与目标数码相同位置的个数
def hx(current):
    count=0
    goal = [1, 2, 3, 8, 0, 4, 7, 6, 5]
    for i in range(len(current)):
        if current[i]==goal[i]:
            count+=1
    return count

def parity(array):
    num = 0
    for i in range(len(array) - 1):
        for j in range(i + 1, len(array)):
            if array[i] == 0 or array[j] == 0:
                continue
            if array[i] < array[j]:
                num += 1
    return num%2

'''
def rand(list):
    a = random.randint(0, 8)
    list.append(a)
    for i in range(8):
        i = random.randint(0, 8)
        while 1:
            if i not in list:
                list.append(i)
                break
            else:
                i = random.randint(0, 8)
'''
if __name__=="__main__":

    #orgin=input(">>").split()
    #start=[int(x) for x in orgin]
    #start=[]
    #rand(start)
    # start=[2,8,3,1,6,4,7,0,5]
    start=[2,8,3,1,0,4,7,6,5]
    goal=[1,2,3,8,0,4,7,6,5]
    # 如果初态和终态的逆序奇偶性不同则无解
    if parity(start) != parity(goal):
        print('该始末状态的8数码无解')
        exit()
    open=[]
    close=[]
    creatpoint=serchpoint=step=0
    open.append([start])
    while 1:
        if start==goal:
            print('初始状态即为解!')
            break
        if len(open)==0:
            print('未找到解')
            break
        else:
            this=open.pop(0)
            #print(this)
            serchpoint+=1
            close.append(this)
            if this[0]==goal:
                print('搜索成功')
                print('共创建{}个结点，共搜索{}个结点,共{}步'.format(creatpoint,serchpoint,len(this)-1))
                for i in this[::-1]:
                    show(i)
                exit()

            #上
            if this[0].index(0)>2 :
                node=this[0].copy()
                a=this[0].index(0)
                b=move('up',a)
                node[a],node[b]=node[b],node[a]
                create(this, node)
                creatpoint += 1

            #下
            if this[0].index(0) < 6 :
                node = this[0].copy()
                a = this[0].index(0)
                b = move('dowm', a)
                node[a],node[b]=node[b],node[a]
                create(this, node)
                creatpoint += 1

            #左
            if this[0].index(0) != 0 and this[0].index(0) != 3 and this[0].index(0) != 6:
                node = this[0].copy()
                a = this[0].index(0)
                b = move('left', a)
                node[a],node[b]=node[b],node[a]
                create(this, node)
                creatpoint += 1

            #右
            if this[0].index(0) != 2 and this[0].index(0) != 5 and this[0].index(0) != 8:
                node = this[0].copy()
                a = this[0].index(0)
                b = move('right', a)
                node[a],node[b]=node[b],node[a]
                create(this, node)
                creatpoint += 1

            #对与目标数码结点相同个数最多的数码结点放到open表最前面
            for i in range(len(open)-1):
                for j in range(i+1,len(open)):
                    if hx(open[i][0])<hx(open[j][0]):
                        open[i],open[j]=open[j],open[i]

示例截图：

在这里插入图片描述

Ning_Y_N
关注
  • 41
    点赞
  • 踩
  • 257
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
DFS求解八数码问题
12-29
在图1，3*3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空。 如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态（图1左）到目标状态（图1右）。 可自行设计初始状态。目标状态为数字从小到大按顺时针排列。
用深度优先、广度优先算法解决八数码问题
04-18
网上大部分解决8数码问题都只采用宽度优先算法。我在宽度优先的基础上，设计出深度优先算法。并制作出界面，方便输入、输出。希望能对学习相关内容的同志有所帮助
【Python】A*八数码问题_求解思路与代码实现
I_no_know_answer的博客
05-21 1402
A*八数码，求解思路与代码实现
人工智能实验——八数码难题
weixin_51735061的博客
05-14 2万+
人工智能实验 八数码难题 利用了BFS算法DFS算法A*算法
【人工智能】基于八数码问题对比搜索算法的性能
满天星的博客
07-27 1858
八数码问题是人工智能的一个经典问题，以宽度优先搜索、深度优先搜索以及A* 算法求解八数码问题。每一种算法都设置相同的初始状态和目标状态，针对搜索策略，求得问题的解，并比较搜索算法的性能以引导分析出更高效的搜索算法策略。...
react 递归遍历四层树结构 遍历分支中的最后一个节点_深度优先遍历、广度优先遍历(dfs,bfs)详解...
weixin_39593340的博客
11-22 311
文章目录前言邻接矩阵和邻接表深度优先搜索(dfs)宽度(广度)优先搜索(bfs)总结与比较前言在有向图和无向图中，如果节点之间无权值或者权值相等，那么dfs和bfs时常出现在日常算法中。不仅如此，dfs，bfs不仅仅能够解决图论的问题，在其他问题的搜索上也是最基础(但是策略不同)的两种经典算法。并且五大经典算法的回溯算法其实也是dfs的一种。dfs,bfs基础能够解决搜索类问题的大部分情况，只不过...
Python/C++: 深度优先搜索DFS解八数码问题
只想AC的博客
05-07 2003
深度优先搜索DFS解八数码问题 题目： ➢在一个３×３的九宫中有1-8这８个数字以及一个空格随机摆放在其中的格子里。将该九宫格调整到目标状态。 ➢规则：每次只能将与空格（上、下、左、右）相邻的一个数字移动到空格中。 ➢备注：为了程序中表示方便，可以用0代替空格。为了程序能正常运行并方便比较，给每个样例设置3个搜索最大深度：5,15,25，设置最大搜索步数是10000步 样例： 样例1： 0 1 3 4 2 5 7 8 6 样例2： 1 5 3 2 4 6 7 0 8 在八数码问题中，深度优先搜索DFS属于盲
八数码问题（8皇后问题）的A*算法求解（Python实现）
06-03
本文介绍了8数码问题，重点讲解了如何使用A*算法进行求解，并提到了其他几种搜索算法，如深度优先搜索、广度优先搜索和有序搜索。Python作为一种强大的编程工具，被用于实现这些算法。理解这些算法及其在8皇后问题上...
八数码问题（数字华容道，九宫格）深度搜索（DFS）广度搜索（BFS）和A*算法C++源码
03-27
通过比较DFS、BFS和A*在解决同一问题上的执行时间和步数，可以深入理解这些算法的优劣。代码应该包含了状态表示、邻接状态生成、搜索过程的实现以及必要的回溯逻辑。 对于学习者来说，分析和运行这段代码有助于加深...
Python实现机器人路径规划实验(A*、BFS、DFS、D*四种路径搜索算法)
最新发布
05-27
在Python实现这四种算法时，通常会用到数据结构如队列（用于BFS）和栈（用于DFS），以及优先级队列（用于A*和D*）。同时，还需要表示地图的二维数组或图数据结构，以及启发式函数（如曼哈顿距离或欧几里得距离）。 ...
Pacman-AI:为 Pacman 游戏实现的 BFS、DFS、A* 和统一成本搜索算法
05-29
2. 实现算法：尝试自己编写 BFS、DFS、A* 和 UCS 算法，然后与提供的实现进行比较，理解其差异。 3. 调整启发式函数：根据游戏规则调整启发式函数，观察算法性能的变化。 4. 观察和分析结果：使用可视化工具观察算法...
七巧板算法（bfs，dfs,贪婪，a*）
07-15
对于固定好的十三个形状（正方形，三角形，多边形等等），如何用七巧板，通过不同的算法。看每一个形状有多少种不同的拼法。python语言编写。
【AI】Python 实现八数码问题
Elford的博客
12-04 5746
八数码问题
三种搜索求解八数码 问题的效率对比
顺子的博客
07-23 7894
问题描述 以宽度优先搜索、深度优先搜索以及A*算法求解八数码问题。每一种算法都设置相同的初始状态和目标状态，针对搜索策略，求得问题的解，并比较搜索算法的性能。 针对下列两种八数码对算法进行对比 （1） （2） 基本原理 图搜索算法介绍 图搜索控制策略是指在图中寻找相应路径的方法。图中的每个节点对应一个状态，每条连线对应一个操作符。图的搜索策略主要有以下几种： 图的搜索策略 各个搜索算法的特点如下: 盲目搜索：没有启发信息的一种搜索形式，不需要重排open表，效率低，耗费过多的计算空
Matlab利用宽度和深度优先搜索解决八数码问题
qq_43470610的博客
08-13 3996
代码结构广度（宽度）优先搜索原理介绍算法理论流程图本次代码的算法步骤设计思路direction（移动方向判定）move(移动目标数据)主执行部分使用模块及变量程序具体流程深度优先搜索原理介绍理论流程图算法思路设计思路direction和move函数和广度搜索一致主执行部分程序设计流程图使用模块及变量 广度（宽度）优先搜索 例子为： 原理介绍 在宽度优先搜索算法中，树上节点的扩展是沿着节点深度的“断层”进行的，也就是说，节点的扩展是按照它们接近起始节点的程度依次进行的。 宽度优先搜索法在对深度为n+1的任一
【转载】八数码问题BFS与DFS的比较
chaideyipi
04-21 8648
吃透算法，搞清原理，终有所得 八数码问题的深度优先及宽度优先算法比较 济南第六职业中等专业学校    王宇    2011年7月17日 16:46 预备知识： 人工智能问题广义地说，都可以看作是一个问题求解过程，因此问题求解是人工智能的核心问题，它通常是通过在某个可能的解答空间中寻找一个解来进行的。在问题求解过程中，人们所面临的大多数现实问题往往没有确定性的算法，通常需要用搜索算法来解决。
dfs和bfs能解决的问题
phantomthief1412的博客
03-24 1059
学习dfs和bfs,并掌握dfs和bfs解决问题的方法
人工智能-A*启发式搜索算法解决八数码问题 Python实现
热门推荐
SCY164759920的博客
10-04 2万+
八数码问题也称为九宫问题。在 3×3 的棋盘，摆有八个棋子，每个棋子上标有 1 至 8 的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格（以数字 0 来表示），与空 格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。该问题可用A*启发式搜索算法求解。
八数码问题（DFS+BFS+A+A*+GUI）
weixin_48186491的博客
04-26 1614
八数码问题的集成解决工具
python制作一个框架，可用BFS DFS与A*三种方法解决九宫重排问题，要求初始状态和最终状态由自己决定
05-27
接下来，我们可以使用 Python 编写一个九宫重排的框架，可以使用 BFS、DFS 和 A* 算法来解决问题。我们可以定义一个类来表示每个状态，其中包含以下属性： - state：表示当前的状态矩阵。 - parent：表示当前状态的...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值