A*算法求解 8 数码问题 python

最新推荐文章于 2024-05-21 17:59:18 发布
最新推荐文章于 2024-05-21 17:59:18 发布
阅读量2.7k 收藏 42
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43840511/article/details/114896854
版权

A*算法是一种启发式图搜索算法，其特点在于对估价函数的定义上。对于一般的启发式图搜索，总是选择估价函数 f 值最小的节点作为扩展节点。因此，f 是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点 n 的估价函数值为两个分量：从起始节点到节点 n 的实际代价 g(n)以及从节点 n 到达目标节点的估价代价 h(n),且h(n) ≤ h *(n) ， h *(n) 为n 节点到目的结点的最优路径的代价。
八数码问题是在 3×3 的九宫格棋盘上，摆有 8 个刻有 1～8 数码的将牌。棋盘中有一个空格，允许紧邻空格的某一将牌可以移到空格中，这样通过平移将牌可以将某一将牌布局变换为另一布局。针对给定的一种初始布局或结构（目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。

运行截图

八数码_不在位数

# -*- coding: utf-8 -*-

import random
import time
import heapq

starttime = time.clock()

end = [[1,2,3],[8,0,4],[7,6,5]]#结束的状态

class maps:
    
    def __init__(self, inf):
        self.posx = 0
        self.posy = 0
        self.value = 0
        self.gn = 0
        
        self.matrix = [[1,2,3],[4,5,6],[7,8,0]]
        for i in range(0,3):
            for j in range(0,3):
                self.matrix[i][j] = inf[i][j]
                if self.matrix[i][j] != end[i][j]:
                    self.value += 1
                if int(inf[i][j]) == 0 :
                    self.posx =i
                    self.posy =j
        
                
    def __lt__(self, other):

        return self.value+ self.gn< other.value+other.gn
    
    def __str__(self):
        return str( self.matrix[0] ) + "\n" +str( self.matrix[1] ) + "\n" +str( self.matrix[2] ) + "\n"


start = maps([[1,3,0],[8,2,4],[7,6,5]])#开始状态

#end = maps([[1,2,3],[4,0,6],[7,5,8]])

if __name__ == '__main__':
    
    tasks = []
    heapq.heappush(tasks,start)#优先队列
    #heapq.heappush(tasks,end)
    flg = [start.matrix]
    pre = [0]
    
    shengcheng=1
    while(len(tasks)>0) :#求解的循环
        
        now = heapq.heappop(tasks)
        pos = flg.index(now.matrix)
        #print("??",now,now.posx,now.posy)
        shengcheng+=1
        
        if now.matrix == end:
            break
        
        if now.posx-1 >= 0:
            tmp = maps(now.matrix)
            tmp.posx = tmp.posx -1 
            tmp.gn += 1 
            
            tmp.matrix[now.posx][now.posy] ,tmp.matrix[now.posx-1][now.posy] = \
            tmp.matrix[now.posx-1][now.posy] ,tmp.matrix[now.posx][now.posy]
            if tmp.matrix not in flg :
                #print("",tmp,tmp.posx,tmp.posy)
                heapq.heappush(tasks,tmp)
                flg.append(tmp.matrix)
                pre.append(pos)
            
        if now.posx+1 < 3:
            tmp = maps(now.matrix)
            tmp.posx = tmp.posx +1 
            tmp.gn += 1 
            
            tmp.matrix[now.posx][now.posy] ,tmp.matrix[now.posx+1][now.posy] = \
            tmp.matrix[now.posx+1][now.posy] ,tmp.matrix[now.posx][now.posy]
            if tmp.matrix not in flg :
                #print("",tmp,tmp.posx,tmp.posy)
                heapq.heappush(tasks,tmp)
                flg.append(tmp.matrix)
                pre.append(pos)
            
        if now.posy-1 >= 0:
            tmp = maps(now.matrix)
            tmp.posy = tmp.posy -1 
            tmp.gn += 1 
            
            tmp.matrix[now.posx][now.posy] ,tmp.matrix[now.posx][now.posy-1] = \
            tmp.matrix[now.posx][now.posy-1] ,tmp.matrix[now.posx][now.posy]
            if tmp.matrix not in flg :
                #print("",tmp,tmp.posx,tmp.posy)
                heapq.heappush(tasks,tmp)
                flg.append(tmp.matrix)
                pre.append(pos)
            
        if now.posy+1 < 3:
            tmp = maps(now.matrix)
            tmp.posy = tmp.posy +1 
            tmp.gn += 1 
            
            tmp.matrix[now.posx][now.posy] ,tmp.matrix[now.posx][now.posy+1] = \
            tmp.matrix[now.posx][now.posy+1] ,tmp.matrix[now.posx][now.posy]
            if tmp.matrix not in flg :
                #print("",tmp,tmp.posx,tmp.posy)
                heapq.heappush(tasks,tmp)
                flg.append(tmp.matrix)
                pre.append(pos)
        
    
    if  now.matrix == end :#输出是否在存在解
        print ("此 8 数码问题存在解")
        
        ans = []
        pos = flg.index(now.matrix)
        
        while pos > 0 :
            ans.append(flg[pos])
            pos = pre[pos]
            
        ans.append(start.matrix)
        ans.reverse()
        for i in ans:
            k = maps(i)
            print(k)
        
    else :
        print ("此 8 数码问题不存在解")
        
        
    endtime = time.clock()
    print('Running time: %s Seconds'%(endtime-starttime))  
    print(len(flg)) 
    print(shengcheng)

八数码_与正确位置之间的曼哈顿距离

# -*- coding: utf-8 -*-

import random
import time
import heapq

starttime = time.clock()

end = [[1,2,3],[8,0,4],[7,6,5]]
mydict = {}

class maps:
    
    def __init__(self, inf):
        self.posx = 0
        self.posy = 0
        self.value = 0
        self.gn = 0
        
        self.matrix = [[1,2,3],[4,5,6],[7,8,0]]
        for i in range(0,3):
            for j in range(0,3):
                self.matrix[i][j] = inf[i][j]
                self.value += abs(mydict[self.matrix[i][j]][0]-i)+abs(mydict[self.matrix[i][j]][1]-j)
                if int(inf[i][j]) == 0 :
                    self.posx =i
                    self.posy =j
                
    def __lt__(self, other):
        
        return self.value+ self.gn< other.value+other.gn
    
    def __str__(self):
        return str( self.matrix[0] ) + "\n" +str( self.matrix[1] ) + "\n" +str( self.matrix[2] ) + "\n"



#end = maps([[1,2,3],[4,0,6],[7,5,8]])

if __name__ == '__main__':
    
    
    for i in range(0,3):
        for j in range(0,3):
            mydict[end[i][j]] = [i,j]
            
    start = maps([[1,3,0],[8,2,4],[7,6,5]])
    
    tasks = []
    heapq.heappush(tasks,start)
    #heapq.heappush(tasks,end)
    flg = [start.matrix]
    pre = [0]
    
    shengcheng=1
    while(len(tasks)>0) :
        
        now = heapq.heappop(tasks)
        pos = flg.index(now.matrix)
        #print("??",now,now.posx,now.posy)
        shengcheng+=1
        
        if now.matrix == end:
            break
        
        if now.posx-1 >= 0:
            tmp = maps(now.matrix)
            tmp.posx = tmp.posx -1 
            tmp.gn += 1 
            
            tmp.matrix[now.posx][now.posy] ,tmp.matrix[now.posx-1][now.posy] = \
            tmp.matrix[now.posx-1][now.posy] ,tmp.matrix[now.posx][now.posy]
            if tmp.matrix not in flg :
                #print("",tmp,tmp.posx,tmp.posy)
                heapq.heappush(tasks,tmp)
                flg.append(tmp.matrix)
                pre.append(pos)
            
        if now.posx+1 < 3:
            tmp = maps(now.matrix)
            tmp.posx = tmp.posx +1 
            tmp.gn += 1 
            
            tmp.matrix[now.posx][now.posy] ,tmp.matrix[now.posx+1][now.posy] = \
            tmp.matrix[now.posx+1][now.posy] ,tmp.matrix[now.posx][now.posy]
            if tmp.matrix not in flg :
                #print("",tmp,tmp.posx,tmp.posy)
                heapq.heappush(tasks,tmp)
                flg.append(tmp.matrix)
                pre.append(pos)
            
        if now.posy-1 >= 0:
            tmp = maps(now.matrix)
            tmp.posy = tmp.posy -1 
            tmp.gn += 1 
            
            tmp.matrix[now.posx][now.posy] ,tmp.matrix[now.posx][now.posy-1] = \
            tmp.matrix[now.posx][now.posy-1] ,tmp.matrix[now.posx][now.posy]
            if tmp.matrix not in flg :
                #print("",tmp,tmp.posx,tmp.posy)
                heapq.heappush(tasks,tmp)
                flg.append(tmp.matrix)
                pre.append(pos)
            
        if now.posy+1 < 3:
            tmp = maps(now.matrix)
            tmp.posy = tmp.posy +1 
            tmp.gn += 1 
            
            tmp.matrix[now.posx][now.posy] ,tmp.matrix[now.posx][now.posy+1] = \
            tmp.matrix[now.posx][now.posy+1] ,tmp.matrix[now.posx][now.posy]
            if tmp.matrix not in flg :
                #print("",tmp,tmp.posx,tmp.posy)
                heapq.heappush(tasks,tmp)
                flg.append(tmp.matrix)
                pre.append(pos)
        
    
    if  now.matrix == end :
        print ("此 8 数码问题存在解")
        
        ans = []
        pos = flg.index(now.matrix)
        
        while pos > 0 :
            ans.append(flg[pos])
            pos = pre[pos]
            
        ans.append(start.matrix)
        ans.reverse()
        for i in ans:
            k = maps(i)
            print(k)
        
    else :
        print ("此 8 数码问题不存在解")
        
        
    endtime = time.clock()
    print('Running time: %s Seconds'%(endtime-starttime))  
    print(len(flg))     
    print(shengcheng)
监心司
关注
  • 0
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
人工智能之启发式搜索算法
admin的博客
09-18 3636
人工智能之启发式搜索算法，头歌educator，AI原理。
【人工智能实验】A*算法求解8数码问题
热门推荐
weixin_43442778的博客
03-21 10万+
1、画出A*算法求解N数码问题的流程图。根据A*算法的实验原理，；这样估价函数f(n)在g(n)一定的情况下，会或多或少的受距离估计值h(n)的制约，节点距目标点近，h值小，f值相对就小，能保证最短路的搜索向终点的方向进行,因此f是根据需要找到一条最小代价路径的观点来估算节点的。设计A*算法的流程图如图4.1.1所示，按照流程图编写伪代码，进而编写完整的程序。其中OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。
【Python】A*八数码问题_求解思路与代码实现
最新发布
I_no_know_answer的博客
05-21 1377
A*八数码，求解思路与代码实现
A*算法解决八数码难题
ZJH
01-21 1万+
基于状态空间表示法的搜索算法解决八数码难题 本文的pdf文件链接：link 一、问题重述 1.1 背景介绍        如今处于人工智能和大数据时代，每天都有成千上万的数据产生，而我们在获取数据的时候需要用到搜索引擎，而互联网中的数据就相当于一颗巨大的树的结点，我们搜索信息的过程实际上就是遍历树的过程，那么搜索算法的好坏将直接决定了我们获取信息的快慢。搜索算法是利用计算机的高性能来有目的的穷举一个问题解空间的部分或所有的可能情况，从而求
Python|A*算法解决八数码问题
weixin_44217002的博客
01-11 9551
一、Dijkstra算法和A*算法比较 Dijkstra算法和A*算法总结 Dijkstra算法计算源点到其他所有点的最短路径长度，A*关注点到点的最短路径(包括具体路径)。 Dijkstra算法建立在较为抽象的图论层面，A*算法可以更轻松地用在诸如游戏地图寻路中。 Dijkstra算法的实质是广度优先搜索，是一种发散式的搜索，所以空间复杂度和时间复杂度都比较高。对路径上的当前点，A*算法不但记录其到源点的代价，还计算当前点到目标点的期望代价，是一种启发式算法，也可以认为是一种深度优先的算法。 由第一
基于pythonA*算法两种搜索算法求解八数码问题
01-22 3222
基于pythonA*算法两种搜索算法求解八数码问题
python---A*搜索算法解决八数码问题
via CHEng的博客
04-30 1万+
A*解决八数码问题
八数码问题（8皇后问题）的A*算法求解（Python实现）
06-03
本文介绍了8数码问题，重点讲解了如何使用A*算法进行求解，并提到了其他几种搜索算法，如深度优先搜索、广度优先搜索和有序搜索。Python作为一种强大的编程工具，被用于实现这些算法。理解这些算法及其在8皇后问题上...
人工智能A*算法15数码python实现
03-12
基于python实现的A*算法15数码，18级学姐自主完成的作业，呕心沥血，如果在语言规范上存在不足，那就。就憋着！哈哈哈哈哈，代码仅供参考，自己亲自码代码更酸爽！
人工智能A*算法求解八数码问题（python语言实现）
01-20
总结来说，"人工智能A*算法求解八数码问题（python语言实现）"这个主题涵盖了以下几个关键知识点： 1. 八数码问题的定义和目标 2. A*算法的原理及其在路径搜索中的应用 3. 曼哈顿距离和切比雪夫距离作为启发式函数 ...
A*算法求解迷宫寻路问题
11-24
使用A*算法求解迷宫寻路问题，使用python编程，人工智能导论课后实验
使用A*算法实现8数码问题的求解
12-18
include using namespace std; struct node{ int nodesun[4][4]; int pre; //上一步在队列中的位置 int flag ; //步数标识，表示当前的步数为有效的 int value; //与目标的差距 int x,y; //空格坐标 }queue[1000]; //移动方向数组 int zx[4]={-1,0,1,0}; int zy[4]={0,-1,0,1}; //当前步数 int top; int desti[4][4];//目标状态 int detect(struct node *p)//检查是否找到 {int i,j; for(i=1;i<4;i++) for(j=1;jnodesun[i][j]!=desti[i][j]) return 0; return 1; } //打印 void printlj() {int tempt; int i,j; tempt=top; while(tempt!=0) { for(i=1;i<4;i++) for(j=1;j<4;j++) {cout<<queue[tempt].nodesun[i][j]; if(j==3) cout<<" "<<endl; } tempt=queue[tempt].pre; } } //现在状态与目标状态有多少个不同位置 int VALUE(struct node *p) {int count=0; int i,j; for(i=1;i<4;i++) for(j=1;jnodesun[i][j]!=desti[i][j]) count++; return count; } void main() { //初始化 int i,j,m,n,f; int min=10; int temp,find=0,minnumber; top=1; for(i=1;i<4;i++) for(j=1;j<4;j++) {cout<<"请输入第"<<i<<"行"<<"第"<<j<<"列的值"<>temp; queue[1].nodesun[i][j]=temp; } cout<<"请输入初始状态的空格的位置(行)"<>temp; queue[1].x=temp; cout<<"请输入初始状态的空格的位置(列)"<>temp; queue[1].y=temp; queue[1].value=VALUE(&queue[1]); queue[1].pre=0; //上一步在队列中的位置 queue[1].flag=0; //目标状态 for(i=1;i<4;i++) for(j=1;j<4;j++) {cout<<"请输入目标状态第"<<i<<"行"<<"第"<<j<<"列的值"<>temp; desti[i][j]=temp; } //根据估价函数 while(!find&&top>0) { for(i=1;i<=top;i++) //////////////////////////////////////////// //min为上一图中与目标图有多少个元素不相同，queue[i]为当前图与目标图有多少个元素不相同通过这两个数的比较，就可以得出当前图较之上一图向目标图接近同时把当前的i记录下来进行下一步比较 {if(queue[i].value<min&&queue[i].flag==0) {minnumber=i;// min=queue[i].value; //还有多少不同的位数 } } queue[minnumber].flag=1; //表示此位有效 ////////////////////////////////////// // for(f=0;f=1&&i=1&&j<=3) {top++; ///////////////////////////////////////////// //位置交换 queue[top]=queue[minnumber]; queue[top].nodesun[m][n]=queue[minnumber].nodesun[i][j]; queue[top].nodesun[i][j]=0; /////////////////////////////////////// //空格移动方向 queue[top].x=i; queue[top].y=j; /////////////////////////////////////// queue[top].pre=minnumber; //上一步在队列中的位置 queue[top].value=VALUE(&queue[top]); //有多少位与目标不同 queue[top].flag=0; //标识位初始化 if(detect(&queue[top])) //检查是否为目标 {printlj(); //打印 find=1; //设找到标识位 break; } } } } }
人工智能-A*算法-八数码问题
xionghui2007的博客
12-04 2841
人工智能，A*算法，八数码问题
A*算法解决八数码问题
ssd_dai的博客
05-04 3万+
以下内容仅是我个人对八数码问题和A*寻路算法的理解，因为我是菜鸟一个，所以写的比较通俗。 八数码问题： 八数码问题也称为九宫问题。在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
A*算法解决八数码问题，对比九数码问题
dick的博客
01-17 4552
A*算法求解八数码问题 Github仓库：https://github.com/dick20/Artificial-Intelligence 问题介绍   八数码问题也称为九宫问题。在3x3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始状态转变成目标...
人工智能实验四：A*搜索求解8数码问题（启发式搜索算法）
落灬枫的博客
03-11 4349
该问题是将与空格相连的数字移动到空格的位置上，也就相当于将空格移动到与之相连的位置，因此，以空格为当前结点，扩展结点可能为上下左右四个相连的位置，若使用一般的搜索算法，可能陷入无限搜索中，永远搜不到目标解，而 A* 搜索算法则能非常好的将搜索过程导向求解目标。所以，要寻找最小代价的解，首先扩展的是g(n)+h(n)值最小的结点。A* 搜索（A 星搜索）是最广为人知的最佳优先搜索，它对结点n的代价评估结合了g(n)，即到达此结点n已经花费的路径代价，和h(n)，即从该结点n到目标结点所花代价。
A*搜索 - 八数码问题
SherlockSheep的博客
10-03 1138
问题描述八数码问题，简单地来描述是这样的：在一个九宫格内，填有1、2、3、4、5、6、7、8，八个阿拉伯数字，有一个格子为空白。就下面这样，这
A*算法求解八数码难题（python实现）
qq_54893805的博客
10-21 1万+
本文用python实现A*算法解决了八数码问题，有被八数码问题困扰的uu们，抓紧时间，进入正文，一定会对你有所帮助！以上就是今天要讲的内容，本文介绍了如何使用python实现A*算法，解决八数码难题，希望能够对uu们有所帮助，如果有uu们有不懂的问题或者有更好的创意和建议，可以在评论区留下宝贵意见，随时欢迎私信博主，给博主点个关注，留个赞，博主不胜感激。
A*算法求解八数码问题实验（详细附代码）
weixin_62344164的博客
05-19 8417
A*算法求解八数码问题实验（详细附代码）
a*算法求解15数码问题python
06-28
较一般性的实现方式是使用循环结构，将每一个数字与15取模得到余数，然后将余数转化成十六进制数中的对应字符。具体实现如下： ``` def base15_to_hex(num): hex_chars = "0123456789ABCDEF" ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值