八数码问题A算法的实现及性能分析
A星算法求解八数码技术报告
A*算法求解八数码问题●open 表、closed 表数据结构的选择：1)把s放入open表，记f=h，令closed为空表。
2)重复下列过程，直到找到目标节点为止。
若open表为空表，则宣告失败。
3)选取open表中未设置过的具有最小f值的节点为最佳节点bestnode，并把它放入closed表。
4)若bestnode为一目标节点，则成功求得一解。
5)若bestnode不是目标节点，则扩展之，产生后继节点succssor。
6)对每个succssor进行下列过称：a)对每个succssor返回bestnode的指针。
b)计算g（suc）=g（bes）+k（bes，suc）。
c)如果succssore open，称此节点为old，并填到bestnode的后继节点表中。
d)比较新旧路劲代价。
如果g（suc）<g(old)，则重新确定old的父辈节点为bestnode，记下较小代价g（old），并修真f（old）值。
e)若至old节点的代价较低或一样，则停止扩展节点。
f)若succssore不再closed表中，则看其是否在closed表中。
g)若succssore在closed表中，则转向（c）。
h)若succssore既不在open表中，又不在closed表中，则把它放入open表中，并添入bestnode后裔表中，然后转向（7）。
i)计算f值j)Go loop●节点的数据结构：static int target[9]={1,2,3,8,0,4,7,6,5}; 全局静态变量，表示目标状态class eight_num{private:int num[9]; 定义八数码的初始状态int not_in_position_num; 定义不在正确位置八数码的个数int deapth; 定义了搜索的深度int eva_function; 评价函数的值，每次选取最小的进行扩展public:eight_num* parent; 指向节点的父节点eight_num* leaf_next; 指向open表的下一个节点eight_num* leaf_pre; 指向open 表的前一个节点初始状态的构造函数eight_num(int init_num[9]);eight_num(int num1,int num2,int num3,int num4,int num5,int num6,int num7,int num8,int num9){}eight_num(void){ }计算启发函数g(n)的值void eight_num::cul_para(void){}显示当前节点的状态void eight_num::show(){}复制当前节点状态到一个另数组中void eight_num::get_numbers_to(int other_num[9]){}设置当前节点状态(欲设置的状态记录的other数组中)void eight_num::set_num(int other_num[9]){}eight_num& eight_num::operator=(eight_num& another_8num){} eight_num& eight_num::operator=(int other_num[9]){}int eight_num::operator==(eight_num& another_8num){}int eight_num::operator==(int other_num[9]){}空格向上移int move_up(int num[9]){}空格向下移int move_down(int num[9]){}空格向左移int move_left(int num[9]){}空格向右移int move_right(int num[9]){}判断可否解出int icansolve(int num[9],int target[9]){}判断有无重复int existed(int num[9],eight_num *where){}寻找估价函数最小的叶子节点eight_num* find_OK_leaf(eight_num* start){}}A*算法求解框图：●分析估价函数对搜索算法的影响：估价函数就是评价函数，它用来评价子结点的好坏，因为准确评价是不可能的，所以称为估值。
A星算法求八数码问题实验报告
A星算法求八数码问题实验报告人工智能实验报告实验名称：八数码问题姓名：xx学号：2012210xxxx计算机学院2014年1月14日一．实验目的掌握A*的思想，启发式搜索，来求解在代价最小的情况下将九宫格从一个状态转为另状态的路径。
二．实验内容给定九宫格的初始状态，要求在有限步的操作内，使其转化为目标状态，且所得到的解是代价最小解(2 8 31 6 47 0 52 8 31 6 47 0 5三、A*算法思想：1、思想：A*算法是一种静态路网中求解最短路最有效的直接搜索方法。
估价值与实际值越接近，估价函数取得就越好2、原理：估价函数公式表示为： f(n)=g(n)+h(n),其中 f(n) 是从初始点经由节点n到目标点的估价函数，g(n) 是在状态空间中从初始节点到n节点的实际代价，h(n) 是从n到目标节点最佳路径的估计代价。
保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取：估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。
但能得到最优解。
并且如果h(n)=d(n)，即距离估计h(n)等于最短距离，那么搜索将严格沿着最短路径进行此时的搜索效率是最高的。
如果估价值>实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。
四、算法流程：Heuristic_Search(启发式搜索)While是从未拓展表中删N为目是，输出路径否，生成n的所有子状态Case:此子状Case:此子状Case:此子状计算该子状记录比已有记录比已有返回五、关键技术：1、使用了CreateChild（）函数，求得了任意未拓展九宫格的扩展结点，便于拓展子空间，搜索所有情况。
关键代码：bool CreateChild(NOExtend ns[],NOExtend ne){int i,j,k=0;for(i=0;i<3;i++){for(j=0;j<3;j++){if(ne.cur_sudoku.num[i][j]==0){ //寻找九宫格空缺所在的坐标if(i-1>=0){ //将空格向上移动CopySudoku(ns[k].cur_sudoku,ne.cur_sudo ku);//先把未改变的九宫格复制给九宫格数组的某一元素ns[k].cur_sudoku.num[i][j]=ne.cur_sudoku.num[i-1][j];//然后仅改变此二维九宫格的两项值即可ns[k].cur_sudoku.num[i-1][j]=0;ns[k].dx=1;k++;}if(j+1<=2){ //将空格向右移动CopySudoku(ns[k].cur_sudoku,ne.cur_sudo ku);ns[k].cur_sudoku.num[i][j]=ns[k].cur_su doku.num[i][j+1];ns[k].cur_sudoku.num[i][j+1]=0;ns[k].dx=1;k++;}if(i+1<=2){ //将空格向下移动CopySudoku(ns[k].cur_sudoku,ne.cur_sudo ku);ns[k].cur_sudoku.num[i][j]=ns[k].cur_su doku.num[i+1][j];ns[k].cur_sudoku.num[i+1][j]=0;ns[k].dx=1;k++;}if(j-1>=0){ //将空格向左移动CopySudoku(ns[k].cur_sudoku,ne.cur_sudo ku);ns[k].cur_sudoku.num[i][j]=ns[k].cur_su doku.num[i][j-1];ns[k].cur_sudoku.num[i][j-1]=0;ns[k].dx=1;k++;}return 1;}}}return 0;2、用启发式搜索函数寻找求解路径，运用了A*算法的思想，能够更快的求解出最优解。
a星算法求解八数码问题python
a星算法求解八数码问题python一、介绍八数码问题是一种经典的智力游戏，也是人工智能领域中的经典问题之一。
在这个问题中，有一个3×3的棋盘，上面摆着1至8这8个数字和一个空格，初始状态和目标状态都已知。
要求通过移动数字，将初始状态变换成目标状态。
其中空格可以和相邻的数字交换位置。
为了解决这个问题，我们可以使用A*算法。
本文将详细介绍如何用Python实现A*算法来求解八数码问题。
二、A*算法简介A*算法是一种启发式搜索算法，常用于寻找最短路径或最优解等问题。
它基于Dijkstra算法，并加入了启发式函数来加速搜索过程。
在A*算法中，每个节点都有两个估价值：g值和h值。
g值表示从起点到该节点的实际代价，h值表示从该节点到目标节点的估计代价。
启发式函数f(n) = g(n) + h(n) 表示从起点到目标节点的估计总代价。
A*算法采用优先队列来保存待扩展的节点，并按照f(n)值从小到大排序。
每次取出队头元素进行扩展，并将扩展出来的新节点按照f(n)值插入队列中。
当扩展出目标节点时，算法结束。
三、八数码问题的状态表示在八数码问题中，每个状态都可以表示为一个3×3的矩阵。
我们可以用一个一维数组来表示这个矩阵，其中0表示空格。
例如，初始状态可以表示为[2, 8, 3, 1, 6, 4, 7, 0, 5]，目标状态可以表示为[1, 2, 3, 8, 0, 4, 7, 6, 5]。
四、A*算法求解八数码问题的步骤1.将初始状态加入优先队列中，并设置g值和h值为0。
2.从队头取出一个节点进行扩展。
如果该节点是目标节点，则搜索结束；否则，将扩展出来的新节点加入优先队列中。
3.对于每个新节点，计算g值和h值，并更新f(n)值。
如果该节点已经在优先队列中，则更新其估价值；否则，将其加入优先队列中。
4.重复第2步至第3步直到搜索结束。
五、Python实现以下是用Python实现A*算法求解八数码问题的代码：```import heapqimport copy# 目标状态goal_state = [1,2,3,8,0,4,7,6,5]# 启发式函数：曼哈顿距离def h(state):distance = 0for i in range(9):if state[i] == 0:continuerow = i // 3col = i % 3goal_row = (state[i]-1) // 3goal_col = (state[i]-1) % 3distance += abs(row - goal_row) + abs(col - goal_col)return distance# A*算法def A_star(start_state):# 初始化优先队列和已访问集合queue = []visited = set()# 将初始状态加入优先队列中，并设置g值和h值为0heapq.heappush(queue, (h(start_state), start_state, 0))while queue:# 取出队头元素进行扩展f, state, g = heapq.heappop(queue)# 如果该节点是目标节点，则搜索结束；否则，将扩展出来的新节点加入优先队列中。
八数码问题 实验报告
八数码问题实验报告八数码问题实验报告引言：八数码问题是一种经典的数学难题，在计算机科学领域有着广泛的研究和应用。
本实验旨在通过探索八数码问题的解法，深入理解该问题的本质，并通过实验结果评估不同算法的效率和准确性。
一、问题描述：八数码问题是一个在3×3的棋盘上，由1至8的数字和一个空格组成的拼图问题。
目标是通过移动棋盘上的数字，使得棋盘上的数字排列按照从小到大的顺序排列，最终形成如下的目标状态：1 2 34 5 67 8二、解法探索：1. 深度优先搜索算法：深度优先搜索算法是一种经典的解决拼图问题的方法。
该算法通过不断尝试所有可能的移动方式，直到找到目标状态或者无法再继续移动为止。
实验结果显示，该算法在八数码问题中能够找到解，但由于搜索空间庞大，算法的时间复杂度较高。
2. 广度优先搜索算法：广度优先搜索算法是另一种常用的解决八数码问题的方法。
该算法通过逐层扩展搜索树，从初始状态开始，逐步扩展所有可能的状态，直到找到目标状态。
实验结果显示，该算法能够找到最短路径的解，但同样面临搜索空间庞大的问题。
3. A*算法：A*算法是一种启发式搜索算法，结合了深度优先搜索和广度优先搜索的优点。
该算法通过使用一个估价函数来评估每个搜索状态的优劣，并选择最有希望的状态进行扩展。
实验结果显示，A*算法在八数码问题中表现出色，能够高效地找到最优解。
三、实验结果与分析：通过对深度优先搜索、广度优先搜索和A*算法的实验，得出以下结论：1. 深度优先搜索算法虽然能够找到解，但由于搜索空间庞大，时间复杂度较高，不适用于大规模的八数码问题。
2. 广度优先搜索算法能够找到最短路径的解，但同样面临搜索空间庞大的问题，对于大规模问题效率较低。
3. A*算法在八数码问题中表现出色，通过合理的估价函数能够高效地找到最优解，对于大规模问题具有较好的效果。
四、结论与展望：本实验通过对八数码问题的解法探索，深入理解了该问题的本质，并评估了不同算法的效率和准确性。
实验三A星算法求解数码问题实验
实验三：A算法求解8数码问题实验一、实验目的熟悉和掌握启发式搜索的定义、估价函数和算法过程;并利用A算法求解N数码难题;理解求解流程和搜索顺序..二、实验内容1、八数码问题描述所谓八数码问题起源于一种游戏:在一个3×3的方阵中放入八个数码1、2、3、4、5、6、7、8;其中一个单元格是空的..将任意摆放的数码盘城初始状态逐步摆成某个指定的数码盘的排列目标状态;如图1所示图1 八数码问题的某个初始状态和目标状态对于以上问题;我们可以把数码的移动等效城空格的移动..如图1的初始排列;数码7右移等于空格左移..那么对于每一个排列;可能的一次数码移动最多只有4中;即空格左移、空格右移、空格上移、空格下移..最少有两种当空格位于方阵的4个角时..所以;问题就转换成如何从初始状态开始;使空格经过最小的移动次数最后排列成目标状态..2、八数码问题的求解算法2.1 盲目搜索宽度优先搜索算法、深度优先搜索算法2.2 启发式搜索启发式搜索算法的基本思想是：定义一个评价函数f;对当前的搜索状态进行评估;找出一个最有希望的节点来扩展..先定义下面几个函数的含义：fn=gn+hn 1式中gn表示从初始节点s到当前节点n的最短路径的耗散值；hn 表示从当前节点n到目标节点g的最短路径的耗散值;fn表示从初始节点s经过n到目标节点g的最短路径的耗散值..评价函数的形式可定义如2式所示：fn=gn+hn 2其中n是被评价的当前节点..fn、gn和hn分别表示是对fn、gn和hn3个函数值的估计值..利用评价函数fn=gn+hn来排列OPEN表节点顺序的图搜索算法称为算法A..在A算法中;如果对所有的x;hx<=hx 3成立;则称好hx为hx的下界;它表示某种偏于保守的估计..采用hx 的下界hx为启发函数的A算法;称为A算法..针对八数码问题启发函数设计如下：fn=dn+pn 4其中A算法中的gn根据具体情况设计为dn;意为n节点的深度;而hn设计为图2 A算法流程图pn;意为放错的数码与正确的位置距离之和..由于实际情况中;一个将牌的移动都是单步进行的;没有交换拍等这样的操作..所以要把所有的不在位的将牌;移动到各自的目标位置上;至少要移动从他们各自的位置到目标位置的距离和这么多次;所以最有路径的耗散值不会比该值小;因此该启发函数hn满足A算法的条件..3、A算法流程图;如图24、A算法总结4.1;把起始状态添加到开启列表..4.2;重复如下工作：a 寻找开启列表中f值最低的节点;我们称它为BESTNOEb 把它切换到关闭列表中..c 对相邻的4个节点中的每一个如果它不在开启列表;也不在关闭列表;把它添加到开启列表中..把BESTNODE作为这一节点的父节点..记录这一节点的f和g值如果它已在开启或关闭列表中;用g值为参考检查新的路径是否更好..更低的g值意味着更好的路径..如果这样;就把这一节点的父节点改为BESTNODE;并且重新计算这一节点的f和g值;如果保持开启列表的f值排序;改变之后需要重新对开启列表排序..d 停止把目标节点添加到关闭列表;这时候路径被找到;或者没有找到路径;开启列表已经空了;这时候路径不存在..4.3;保存路径..从目标节点开始;沿着每一节点的父节点移动直到回到起始节点..这就是求得的路径..5、数据结构采用结构体来保存八数码的状态、f和g的值以及该节点的父节点；struct Node{int s33;//保存八数码状态;0代表空格int f;g;//启发函数中的f和g值struct Node next;struct Node previous;//保存其父节点};6、实验结果;如图3所示图3 A算法求解八数码问题实验结果7、源代码//-----------------------------------------------------------------------------//代码：利用A算法求解八数码问题..//八数码问题的启发函数设计为：fn=dn+pn;其中A算法中的gn根据具体情况设计为dn;意为n节点的深度;而hn设计为pn;意为放错的数码与正确的位置距离之和..//后继结点的获取：数码的移动等效为空格的移动..首先判断空格上下左右的可移动性;其次移动空格获取后继结点..//-----------------------------------------------------------------------------include<stdio.h>include<stdlib.h>include<math.h>//八数码状态对应的节点结构体struct Node{int s33;//保存八数码状态;0代表空格int f;g;//启发函数中的f和g值struct Node next;struct Node previous;//保存其父节点 };int open_N=0; //记录Open列表中节点数目//八数码初始状态int inital_s33={2;8;3;1;6;4;7;0;5};//八数码目标状态int final_s33={1;2;3;8;0;4;7;6;5};//------------------------------------------------------------------------//添加节点函数入口;方法：通过插入排序向指定表添加//------------------------------------------------------------------------void Add_Node struct Node head; struct Node p{struct Node q;ifhead->next//考虑链表为空{ q = head->next;ifp->f < head->next->f{//考虑插入的节点值比链表的第一个节点值小p->next = head->next;head->next = p;}else {whileq->next//考虑插入节点x;形如a<= x <=b{ifq->f < p->f ||q->f == p->f && q->next->f > p->f || q->next->f == p->f{p->next = q->next;q->next = p;break;}q = q->next;}ifq->next == NULL //考虑插入的节点值比链表最后一个元素的值更大q->next = p;}}else head->next = p;}//------------------------------------------------------------------------//删除节点函数入口//------------------------------------------------------------------------void del_Nodestruct Node head; struct Node p{struct Node q;q = head;whileq->next{ifq->next == p{q->next = p->next;p->next = NULL;ifq->next == NULL return;// freep;}q = q->next;}}//------------------------------------------------------------------------//判断两个数组是否相等函数入口//------------------------------------------------------------------------int equalint s133; int s233{int i;j;flag=0;fori=0; i< 3 ; i++forj=0; j< 3 ;j++ifs1ij = s2ij{flag = 1; break;}ifflagreturn 1;else return 0;}//------------------------------------------------------------------------//判断后继节点是否存在于Open或Closed表中函数入口//------------------------------------------------------------------------int exit_Nodestruct Node head;int s33; struct Node Old_Node{struct Node q=head->next;int flag = 0;whileqifequalq->s;s {flag=1;Old_Node->next = q;return 1;}else q = q->next;ifflag return 0;}//-------------------------------------------------------------//计算pn的函数入口//其中pn为放错位的数码与其正确的位置之间距离之和//具体方法：放错位的数码与其正确的位置对应下标差的绝对值之和//------------------------------------------------------------------------int wrong_sumint s33{int i;j;fi;fj;sum=0;fori=0 ; i<3; i++forj=0; j<3; j++{forfi=0; fi<3; fi++forfj=0; fj<3; fj++iffinal_sfifj == sij{sum += fabsi - fi + fabsj - fj;break;}}return sum;}//-------------------------------------------------------------//获取后继结点函数入口//检查空格每种移动的合法性;如果合法则移动空格得到后继结点//------------------------------------------------------------------------int get_successorstruct Node BESTNODE; int direction; struct Node Successor//扩展BESTNODE;产生其后继结点SUCCESSOR{int i;j;i_0;j_0;temp;fori=0; i<3; i++forj=0; j<3; j++Successor->sij = BESTNODE->sij;//获取空格所在位置fori=0; i<3; i++forj=0; j<3; j++ifBESTNODE->sij == 0{i_0 = i; j_0 = j;break;}switchdirection{case 0: ifi_0-1>-1 {temp = Successor->si_0j_0;Successor->si_0j_0 = Successor->si_0-1j_0;Successor->si_0-1j_0 = temp;return 1;}else return 0;case 1: ifj_0-1>-1{temp = Successor->si_0j_0;Successor->si_0j_0 = Successor->si_0j_0-1;Successor->si_0j_0-1 = temp;return 1;}else return 0;case 2: if j_0+1<3{temp = Successor->si_0j_0;Successor->si_0j_0 = Successor->si_0j_0+1;Successor->si_0j_0+1 = temp;return 1;}else return 0;case 3: ifi_0+1<3 {temp = Successor->si_0j_0;Successor->si_0j_0 = Successor->si_0+1j_0;Successor->si_0+1j_0 = temp;return 1;}else return 0;}}//------------------------------------------------------------------------//从OPen表获取最佳节点函数入口//------------------------------------------------------------------------struct Node get_BESTNODEstruct Node Open{return Open->next;}//------------------------------------------------------------------------//输出最佳路径函数入口//------------------------------------------------------------------------void print_Pathstruct Node head{struct Node q; q1;p;int i;j;count=1;p = struct Node mallocsizeofstruct Node;//通过头插法变更节点输出次序p->previous = NULL;q = head;whileq{q1 = q->previous;q->previous = p->previous;p->previous = q;q = q1;}q = p->previous;whileq{ifq == p->previousprintf"八数码的初始状态：\n";else ifq->previous == NULLprintf"八数码的目标状态：\n"; else printf"八数码的中间态%d\n";count++;fori=0; i<3; i++forj=0; j<3; j++{printf"%4d";q->sij;ifj == 2printf"\n";}printf"f=%d; g=%d\n\n";q->f;q->g;q = q->previous;}}//------------------------------------------------------------------------//A子算法入口:处理后继结点//------------------------------------------------------------------------void sub_A_algorithmstruct Node Open; struct Node BESTNODE; struct Node Closed;struct Node Successor{struct Node Old_Node = struct Node mallocsizeofstruct Node;Successor->previous = BESTNODE;//建立从successor返回BESTNODE 的指针Successor->g = BESTNODE->g + 1;//计算后继结点的g值//检查后继结点是否已存在于Open和Closed表中;如果存在：该节点记为old_Node;比较后继结点的g值和表中old_Node节点//g值;前者小代表新的路径比老路径更好;将Old_Node的父节点改为BESTNODE;并修改其f;g值;后者小则什么也不做..//即不存在Open也不存在Closed表则将其加入OPen表;并计算其f值if exit_NodeOpen; Successor->s; Old_Node {ifSuccessor->g < Old_Node->g{Old_Node->next->previous = BESTNODE;//将Old_Node的父节点改为BESTNODEOld_Node->next->g = Successor->g;//修改g值Old_Node->next->f = Old_Node->g + wrong_sumOld_Node->s;//修改f值//排序~~~~~~~~~~~~~~~~~~del_NodeOpen; Old_Node;Add_NodeOpen; Old_Node;}}else if exit_NodeClosed; Successor->s; Old_Node{ifSuccessor->g < Old_Node->g{Old_Node->next->previous = BESTNODE;Old_Node->next->g = Successor->g;Old_Node->next->f = Old_Node->g + wrong_sumOld_Node->s;//排序~~~~~~~~~~~~~~~~~~del_NodeClosed; Old_Node;Add_NodeClosed; Old_Node;}}else {Successor->f = Successor->g + wrong_sumSuccessor->s;Add_NodeOpen; Successor;open_N++;}}//------------------------------------------------------------------------//A算法入口//八数码问题的启发函数为：fn=dn+pn//其中A算法中的gn根据具体情况设计为dn;意为n节点的深度;而hn设计为pn;//意为放错的数码与正确的位置距离之和//------------------------------------------------------------------------void A_algorithmstruct Node Open; struct Node Closed //A算法{int i;j;struct Node BESTNODE; inital; Successor;inital = struct Node mallocsizeofstruct Node;//初始化起始节点fori=0; i<3; i++forj=0; j<3; j++inital->sij = inital_sij;inital->f = wrong_suminital_s;inital->g = 0;inital->previous = NULL;inital->next = NULL;Add_NodeOpen; inital;//把初始节点放入OPEN表open_N++;while1{ifopen_N == 0{printf"failure"; return;}else {BESTNODE = get_BESTNODEOpen;//从OPEN表获取f值最小的BESTNODE;将其从OPEN表删除并加入CLOSED表中del_NodeOpen; BESTNODE;open_N--;Add_NodeClosed; BESTNODE;ifequalBESTNODE->s; final_s {//判断BESTNODE是否为目标节点printf"success\n";print_PathBESTNODE;return;}//针对八数码问题;后继结点Successor的扩展方法：空格二维数组中的0上下左右移动;//判断每种移动的有效性;有效则转向A子算法处理后继节点;否则进行下一种移动else{Successor = struct Node mallocsizeofstruct Node; Successor->next = NULL;ifget_successorBESTNODE; 0; Successorsub_A_algorithm Open; BESTNODE; Closed; Successor;Successor = struct Node mallocsizeofstruct Node; Successor->next = NULL;ifget_successorBESTNODE; 1; Successorsub_A_algorithm Open; BESTNODE; Closed; Successor;Successor = struct Node mallocsizeofstruct Node; Successor->next = NULL;ifget_successorBESTNODE; 2; Successorsub_A_algorithm Open; BESTNODE; Closed; Successor;Successor = struct Node mallocsizeofstruct Node; Successor->next = NULL;ifget_successorBESTNODE; 3; Successorsub_A_algorithm Open; BESTNODE; Closed; Successor;}}}}//------------------------------------------------------------------------//main函数入口//定义Open和Closed列表..Open列表：保存待检查节点..Closed列表：保存不需要再检查的节点//------------------------------------------------------------------------void main{struct Node Open = struct Node mallocsizeofstruct Node;struct Node Closed = struct Node mallocsizeofstruct Node;Open->next = NULL ; Open->previous = NULL;Closed->next =NULL; Closed->previous = NULL;A_algorithmOpen; Closed;}三、实验体会通过这次实验;使我对启发式搜索算法有了更进一步的理解;特别是估计函数hn所起到的巨大重用..一个好的估计函数对于启发式搜索算法来说是十分关键的..。
基于启发式搜索算法A星解决八数码问题
int statue[size][size]; //记录当前节点的状态 struct Node * Tparent; //用来构成搜索树，该树由搜索图的反向指针构成 struct Node * opennext; //用来构成 open 表，该指针指向该节点在 open 表中的下一个 节点 struct Node * closenext; //用来构成 open 表，该指针指向该节点在 close 表中的下一个 节点 struct Node * brothernext; //构成兄弟链表，该指针指向该节点在兄弟链表中的下一个节 点 int f; //记录当前节点的 f 函数值 int g; //记录当前节点的 g 函数的值 int h; //记录当前节点的 h 函数的值 };
5
get_bestroute (bestNode); return; }
2.2.7 生成 bestNode 所指节点的后继节点
定义一个后继节点链表，表头为 head_b，将 bestNode 所指节点的不是前驱节点的后继 节点，链接到后继及诶单链表中。getchild 函数可以实现这个功能。
//产生 bestNode 的一切后继节点。。 head head_b; //定义 bestNode 的后继节点表 head_b.next=NULL; getchild (&head_b,bestNode); //产生 bestNode 的子节点，将不是 bestNode 的父节点的
while (head_b.next!=NULL) { Node *tmp=getbrother (&head_b); //从后继节点表中取出一个节点记为 tmp，并从
八数码 人工智能实验报告
八数码人工智能实验报告八数码人工智能实验报告引言：八数码是一种经典的数学问题，也是人工智能领域中常用的实验题目之一。
本次实验旨在通过使用搜索算法解决八数码问题，探讨人工智能在解决复杂问题上的应用。
一、问题描述：八数码问题是一种数字排列游戏，使用一个3x3的方格，其中8个方格上各有一个数字，剩下一个方格为空白。
通过移动数字方格，最终将数字按照从小到大的顺序排列，空白方格位于最后一个位置。
例如，初始状态为：1 2 38 47 6 5目标状态为：1 2 34 5 67 8二、算法选择：本次实验采用了A*搜索算法来解决八数码问题。
A*算法是一种启发式搜索算法，通过估计每个搜索节点到达目标状态的代价来进行搜索。
它综合了广度优先搜索和最佳优先搜索的优点，能够高效地找到最优解。
三、实验过程：1. 状态表示：在实验中，我们使用一个3x3的二维数组来表示八数码的状态。
数组中的每个元素代表一个方格的数字，空白方格用0表示。
2. 启发函数：为了评估每个搜索节点到达目标状态的代价，我们需要定义一个启发函数。
本实验中，我们选择了曼哈顿距离作为启发函数。
曼哈顿距离是指每个数字方格与其目标位置之间的水平和垂直距离之和。
3. A*算法：A*算法的核心思想是维护一个优先队列，根据每个搜索节点的估价函数值进行排序。
具体步骤如下：- 将初始状态加入优先队列，并设置初始估价函数值为0。
- 从优先队列中取出估价函数值最小的节点，进行扩展。
- 对于每个扩展节点，计算其估价函数值，并将其加入优先队列。
- 重复上述步骤，直到找到目标状态或者队列为空。
四、实验结果：经过实验，我们发现A*算法能够高效地解决八数码问题。
对于初始状态为随机排列的八数码，A*算法能够在较短的时间内找到最优解。
实验结果表明，A*算法在解决八数码问题上具有较好的性能。
五、实验总结：本次实验通过使用A*搜索算法解决八数码问题，展示了人工智能在解决复杂问题上的应用。
A*算法通过合理的启发函数和优先队列的维护，能够高效地找到最优解。
a算法求解八数码问题 实验报告
题目: a算法求解八数码问题实验报告目录1. 实验目的2. 实验设计3. 实验过程4. 实验结果5. 实验分析6. 实验总结1. 实验目的本实验旨在通过实验验证a算法在求解八数码问题时的效果，并对其进行分析和总结。
2. 实验设计a算法是一种启发式搜索算法，主要用于在图形搜索和有向图中找到最短路径。
在本实验中，我们将使用a算法来解决八数码问题，即在3x3的九宫格中，给定一个初始状态和一个目标状态，通过移动数字的方式将初始状态转变为目标状态。
具体的实验设计如下：1) 实验工具：我们将使用编程语言来实现a算法，并结合九宫格的数据结构来解决八数码问题。
2) 实验流程：我们将设计一个初始状态和一个目标状态，然后通过a 算法来求解初始状态到目标状态的最短路径。
在求解的过程中，我们将记录下每一步的状态变化和移动路径。
3. 实验过程我们在编程语言中实现了a算法，并用于求解八数码问题。
具体的实验过程如下：1) 初始状态和目标状态的设计：我们设计了一个初始状态和一个目标状态，分别为：初始状态：1 2 34 5 67 8 0目标状态：1 2 38 0 42) a算法求解：我们通过a算法来求解初始状态到目标状态的最短路径，并记录下每一步的状态变化和移动路径。
3) 实验结果在实验中，我们成功求解出了初始状态到目标状态的最短路径，并记录下了每一步的状态变化和移动路径。
具体的实验结果如下：初始状态：1 2 34 5 67 8 0目标状态：1 2 38 0 47 6 5求解路径：1. 上移1 2 37 8 62. 左移1 2 3 4 0 5 7 8 63. 下移1 2 3 4 8 5 7 0 64. 右移1 2 3 4 8 5 0 7 65. 上移1 2 3 0 8 5 4 7 61 2 38 0 54 7 67. 下移1 2 38 7 54 0 68. 右移1 2 38 7 54 6 0共计8步，成功从初始状态到目标状态的最短路径。
八数码问题实验报告
八数码问题实验报告八数码问题实验报告引言：八数码问题，也被称为九宫格问题，是一种经典的数学谜题。
在一个3x3的方格中，摆放有1至8的数字，其中一个位置为空。
目标是通过交换数字的位置，将数字按照从小到大的顺序排列，最终使得空格位于最后一个位置。
本实验旨在通过编程实现八数码问题的求解，并探讨不同算法在解决该问题上的效果和优劣。
实验步骤：1. 算法选择在本次实验中，我们选择了广度优先搜索算法和A*算法作为求解八数码问题的两种不同方法。
广度优先搜索算法是一种盲目搜索算法，它通过逐层扩展搜索树，直到找到目标状态。
而A*算法则是一种启发式搜索算法，它结合了广度优先搜索和启发式函数，通过评估每个状态的代价来指导搜索过程，以找到最优解。
2. 算法实现我们使用Python语言实现了以上两种算法。
首先，我们定义了一个表示状态的类，并实现了状态的初始化、移动、判断是否达到目标状态等基本操作。
然后，我们分别编写了广度优先搜索算法和A*算法的求解函数。
在广度优先搜索算法中，我们使用队列数据结构来保存待扩展的状态，以实现逐层扩展的效果；在A*算法中，我们使用优先队列来保存待扩展的状态，并根据启发式函数的值进行优先级排序。
3. 实验结果我们使用了多个测试样例来验证两种算法的求解效果。
实验结果表明，广度优先搜索算法能够找到解，但是在面对状态空间较大的情况下，搜索时间会呈指数级增长。
而A*算法则能够更快地找到最优解，其效率相对较高。
然而，A*算法需要选择合适的启发式函数，并且对于某些特殊情况，可能会陷入局部最优解而无法找到最优解。
4. 结果分析通过对比两种算法的求解结果，我们可以发现广度优先搜索算法和A*算法在时间效率和解的质量上存在一定的差异。
广度优先搜索算法适用于状态空间较小的情况，但是在状态空间较大时效率较低；而A*算法则能够在较短的时间内找到最优解，但需要对问题进行合理的建模和启发式函数的选择。
因此，在实际应用中，我们需要根据问题的规模和特点来选择合适的算法。
课程设计 用A算法解决8数码问题
课程设计用A算法解决8数码问题
8数码问题是一个组合优化问题，是指给定8个数字，请将这些数字填入九宫格，使
九宫格中每行、列、粗实线和细实线中的数字之和都相等。
本文重点讨论的是用A算法解
决8数码问题的方法，即A算法估价函数。
A算法属于启发式搜索，它的原理是：先计算当前状态的分数，再根据该分数估计状
态所代表的最终的价值，以作为当前局面的启发，判断当前局面是否是最优局面。
针对 8数码问题，A算法估价函数可计算九宫格每行、列和粗实线差值总和，它代表
九宫格中九位之和是如何与其目标值（45）的偏差程度。
根据九宫格中九位之和的偏差程
度定义该九宫格的分数：若九位之和与其目标值相等，则分数成为 0；若差值跨越两个数字，则分数变为 2；若差值跨越一个数字，则分数变为 1。
有了这一定义，A算法便可应
用在8数码问题中了。
正如上述，A算法估价函数的总分数可由九宫格所有表项的偏差程度来定义，若九宫
格所有表项的结果均跟其目标值（45）相等，总分数则为 0，反之则不是，总分数就会根
据表项有多大的偏差程度来决定。
然后A算法搜索遍历到的每个状态都可以根据它对应的
分数计算当前状态的价值，以作为启发，最终定位最优状态。
从理论上讲，A算法可以在求解8数码问题时取得良好的运算的结果，它可以很好的
评估问题的最优解，因此使得搜索树更加有效，从而减少计算机运算时间，提升解答效率。
人工智能-A算法求解8数码问题
实验四 A*算法求解8数码问题一、实验目的熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解8数码难题，理解求解流程和搜索顺序。
二、实验原理A*算法是一种启发式图搜索算法，其特点在于对估价函数的定义上。
对于一般的启发式图搜索，总是选择估价函数f值最小的节点作为扩展节点。
因此，f 是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点n的估价函数值为两个分量：从起始节点到节点n的实际代价g(n)以及从节点n 到达目标节点的估价代价h(n)，且h(n)<=h*(n)，h*(n)为n节点到目标节点的最优路径的代价。
八数码问题是在3×3的九宫格棋盘上，排放有8个刻有1～8数码的将牌。
棋盘中有一个空格，允许紧邻空格的某一将牌可以移到空格中，这样通过平移将牌可以将某一将牌布局变换为另一布局。
针对给定的一种初始布局或结构（目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。
如图1所示表示了一个具体的八数码问题求解。
图1 八数码问题的求解三、实验内容1、参考A*算法核心代码，以8数码问题为例实现A*算法的求解程序（编程语言不限），要求设计两种不同的估价函数。
2、在求解8数码问题的A*算法程序中，设置相同的初始状态和目标状态，针对不同的估价函数，求得问题的解，并比较它们对搜索算法性能的影响，包括扩展节点数、生成节点数等。
3、对于8数码问题，设置与图1所示相同的初始状态和目标状态，用宽度优先搜索算法（即令估计代价h(n)＝0的A*算法）求得问题的解，记录搜索过程中的扩展节点数、生成节点数。
4、提交实验报告和源程序。
四.实验截图五．源代码#include<iostream>#include"stdio.h"#include"stdlib.h"#include"time.h"#include"string.h"#include<queue>#include<stack>using namespace std;const int N=3;//3*3棋?盘ìconst int Max_Step=32;//最?大洙?搜?索÷深?度èenum Direction{None,Up,Down,Left,Right};//方?向ò，?分?别纄对?应畖上?下?左哩?右?struct Chess//棋?盘ì{int chessNum[N][N];//棋?盘ì数簓码?int Value;//评à估à值μDirection BelockDirec;//所ù屏á蔽?方?向òstruct Chess * Parent;//父?节ú点?};void PrintChess(struct Chess *TheChess);//打洙?印?棋?盘ìstruct Chess * MoveChess(struct Chess * TheChess,Direction Direct,bool CreateNewChess);//移?动ˉ棋?盘ì数簓字?int Appraisal(struct Chess * TheChess,struct Chess * Target);//估à价?函ˉ数簓struct Chess * Search(struct Chess* Begin,struct Chess * Target);//A*搜?索÷函ˉ数簓int main(){//本?程ì序ò的?一?组哩?测a试?数簓据Y为a/*初?始?棋?盘ì*1 4 0**3 5 2**6 7 8**//*目?标括?棋?盘ì*0 1 2**3 4 5**6 7 8**/Chess Target;Chess *Begin,*ChessList;Begin=new Chess;int i;cout<<"请?输?入?初?始?棋?盘ì，?各÷数簓字?用?空?格?隔?开a：阰"<<endl;for(i=0;i<N;i++){for(int j=0;j<N;j++){cin>>Begin->chessNum[i][j];}}cout<<"请?输?入?目?标括?棋?盘ì，?各÷数簓字?用?空?格?隔?开a：阰"<<endl;for(i=0;i<N;i++){for(int j=0;j<N;j++){cin>>Target.chessNum[i][j];}}//获?取?初?始?棋?盘ìAppraisal(Begin,&Target);Begin->Parent=NULL;Begin->BelockDirec=None;Target.Value=0;cout<<"初?始?棋?盘ì:";PrintChess(Begin);cout<<"目?标括?棋?盘ì:";PrintChess(&Target);ChessList=Search(Begin,&Target);//搜?索÷//打洙?印?if(ChessList){/*将?返う?回?的?棋?盘ì列表括?利?用?栈?将?其?倒?叙e*/Chess *p=ChessList;stack<Chess *>Stack;while(p->Parent!=NULL){Stack.push(p);p=p->Parent;}cout<<"搜?索÷结á果?:"<<endl;int num=1;while(!Stack.empty()){cout<<"第台?<<num<<"步?: ";num++;PrintChess(Stack.top());Stack.pop();}cout<<"\n完?成é!"<<endl;}elsecout<<"搜?索÷不?到?结á果?，?搜?索÷深?度è大洙?于?2\n"<<endl;return 0;}//打洙?印?棋?盘ìvoid PrintChess(struct Chess *TheChess){cout<<"(评à估à值μ为a";cout<<TheChess->Value;cout<<")"<<endl;for(int i=0;i<N;i++){cout<<" ";for(int j=0;j<N;j++){cout<<TheChess->chessNum[i][j]<<" ";}cout<<endl;}}//移?动ˉ棋?盘ìstruct Chess * MoveChess(struct Chess * TheChess,Direction Direct,bool CreateNewChess) {struct Chess * NewChess;//获?取?空?闲D格?位?置?int i,j;for(i=0;i<N;i++){bool HasGetBlankCell=false;for(j=0;j<N;j++){if(TheChess->chessNum[i][j]==0){HasGetBlankCell=true;break;}}if(HasGetBlankCell)break;}int ii=i,jj=j;bool AbleMove=true;//判D断?是?否?可é以?移?动ˉswitch(Direct){case Up:i++;if(i>=N)AbleMove=false;break;case Down:i--;if(i<0)AbleMove=false;break;case Left:j++;if(j>=N)AbleMove=false;break;case Right:j--;if(j<0)AbleMove=false;break;};if(!AbleMove)//不?可é以?移?动ˉ则ò返う?回?原-节ú点?{return TheChess;}if(CreateNewChess){NewChess=new Chess();for(int x=0;x<N;x++){for(int y=0;y<N;y++)NewChess->chessNum[x][y]=TheChess->chessNum[x][y];//创洹?建¨新?棋?盘ì，?此?时骸?值μ与?原-棋?盘ì一?致?}}elseNewChess=TheChess;NewChess->chessNum[ii][jj] = NewChess->chessNum[i][j];//移?动ˉ数簓字?NewChess->chessNum[i][j]=0;//将?原-数簓字?位?置?设Θ?置?为a空?格?return NewChess;}//估à价?函ˉ数簓int Appraisal(struct Chess * TheChess,struct Chess * Target){int Value=0;for(int i=0;i<N;i++){for(int j=0;j<N;j++){if(TheChess->chessNum[i][j]!=Target->chessNum[i][j])Value++;}}TheChess->Value=Value;return Value;}//A*搜?索÷函ˉ数簓struct Chess * Search(struct Chess* Begin,struct Chess * Target){Chess *p1,*p2,*p;int Step=0;//深?度èp=NULL;queue<struct Chess *> Queue;Queue.push(Begin);//初?始?棋?盘ì入?队ó//搜?索÷do{p1=(struct Chess *)Queue.front();Queue.pop();//出?队ófor(int i=1;i<=4;i++)//分?别纄从洙?四?个?方?向ò推?导?出?新?子哩?节ú点? {Direction Direct=(Direction)i;if(Direct==p1->BelockDirec)//跳?过y屏á蔽?方?向òcontinue;p2=MoveChess(p1,Direct,true);//移?动ˉ数簓码?if(p2!=p1)//数簓码?是?否?可é以?移?动ˉ{Appraisal(p2,Target);//对?新?节ú点?估à价?if(p2->Value<=p1->Value)//是?否?为a优?越?节ú点?{p2->Parent=p1;switch(Direct)//设Θ?置?屏á蔽?方?向ò,防え?止1往?回?推?{case Up:p2->BelockDirec=Down;break;case Down:p2->BelockDirec=Up;break;case Left:p2->BelockDirec=Right;break;case Right:p2->BelockDirec=Left;break;}Queue.push(p2);//存?储洹?节ú点?到?待鋣处鋦理え?队ó列if(p2->Value==0)//为a0则ò,搜?索÷完?成é{p=p2;i=5;}}else{delete p2;//为a劣ⅷ?质ê节ú点?则ò抛×弃úp2=NULL;}}}Step++;if(Step>Max_Step)return NULL;}while(p==NULL || Queue.size()<=0);return p;}六、实验报告要求1、分析不同的估价函数对A*搜索算法性能的影响等。
人工智能A算法八数码报告
人工智能A算法八数码报告
一、什么是人工智能A算法八数码？
二、人工智能A算法八数码原理
八数码问题可以用一个3x3矩阵表示，一个有效路径是由空格移动到另一个位置的路径，它可以在矩阵中上下左右移动，直到所有数字都按从小到大的顺序排列好。
但是，由于有很多种移动的可能性，有效的路径非常难以找到，并且需要大量的计算来完成。
这就是人工智能A算法八数码可以帮助用户解决的问题。
该算法采用了蚁群算法的变种，每个蚂蚁都可以把有效路径拆分成四个状态：移动空格，改变表格上的数字，计算移动的路径，并求出路径的代价（代价是一个函数，用于衡量当前路径和有效路径之间的差异）。
用A星算法解决八数码问题
A*算法解决八数码问题1 问题描述什么是八数码问题八数码游戏包括一个3×3的棋盘，棋盘上摆放着8个数字的棋子，留下一个空位。
与空位相邻的棋子可以滑动到空位中。
游戏的目的是要达到一个特定的目标状态。
标注的形式化如下：问题的搜索形式描述状态：状态描述了8个棋子和空位在棋盘的9个方格上的分布。
初始状态：任何状态都可以被指定为初始状态。
操作符：用来产生4个行动（上下左右移动）。
目标测试：用来检测状态是否能匹配上图的目标布局。
路径费用函数：每一步的费用为1，因此整个路径的费用是路径中的步数。
现在任意给定一个初始状态，要求找到一种搜索策略，用尽可能少的步数得到上图的目标状态。
解决方案介绍算法思想(估价函数是搜索特性的一种数学表示，是指从问题树根节点到达目标节点所要耗费的全部代价的一种估算，记为f(n)。
估价函数通常由两部分组成，其数学表达式为f(n)=g(n)+h(n)其中f(n) 是节点n从初始点到目标点的估价函数，g(n) 是在状态空间中从初始节点到n 节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。
保证找到最短路径（最优解）的条件，关键在于估价函数h(n)的选取。
估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。
但能得到最优解。
如果估价值>实际值, 搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。
搜索中利用启发式信息，对当前未扩展结点根据设定的估价函数值选取离目标最近的结点进行扩展，从而缩小搜索空间，更快的得到最优解，提高效率。
启发函数进一步考虑当前结点与目标结点的距离信息，令启发函数h ( n )为当前8个数字位与目标结点对应数字位距离和（不考虑中间路径），且对于目标状态有 h ( t ) = 0，对于结点m和n （n 是m的子结点）有h ( m ) – h ( n ) <= 1 = Cost ( m, n ) 满足单调限制条件。
人工智能实验报告 八数码
人工智能实验报告八数码人工智能实验报告八数码引言：人工智能（Artificial Intelligence，简称AI）作为一门前沿的学科，已经在各个领域展现出了巨大的应用潜力。
其中，八数码问题作为一个经典的算法问题，被广泛应用于人工智能领域。
本文将对八数码问题进行实验研究，探讨其在人工智能中的应用。
一、八数码问题的定义八数码问题是指在一个3x3的棋盘上，摆放有1至8这8个数字，其中一个格子为空。
玩家需要通过移动数字，使得棋盘上的数字按照从小到大的顺序排列，空格在最后。
八数码问题可以被抽象为一个搜索问题，即找到从初始状态到目标状态的最短路径。
二、实验方法为了解决八数码问题，我们采用了A*算法作为实验方法。
A*算法是一种启发式搜索算法，通过估计目标状态与当前状态之间的代价函数，选择最优的路径进行搜索。
在本次实验中，我们将使用曼哈顿距离作为代价函数进行搜索。
三、实验结果我们使用Python编程语言实现了八数码问题的求解算法，并进行了多组实验。
实验结果表明，A*算法在解决八数码问题上表现出了较好的效果。
在大部分情况下，A*算法能够在较短的时间内找到最优解。
四、实验讨论尽管A*算法在解决八数码问题上表现出了较好的效果，但我们也发现了一些问题。
首先，A*算法在面对复杂的八数码问题时，搜索时间会显著增加。
其次，A*算法在面对某些特定情况时，可能会陷入局部最优解，无法找到全局最优解。
这些问题需要进一步的研究和改进。
五、应用前景八数码问题作为人工智能领域的经典问题，有着广泛的应用前景。
首先，八数码问题可以被应用于游戏设计中，作为一种智能对手的算法。
其次，八数码问题的解决方法可以被应用于路径规划、图像识别等领域，提高算法的效率和准确性。
六、结论通过本次实验，我们对八数码问题进行了深入的研究和探讨。
A*算法作为一种启发式搜索算法，在解决八数码问题上表现出了较好的效果。
然而，八数码问题仍然存在一些挑战和问题，需要进一步的研究和改进。
八数码问题A算法的实现及性能分析
八数码问题A＊算法的实现及性能分析计算机科学与技术学院专业:计算机科学与技术161210404 杨凯迪目录一、8数码问题 (3)1.问题描述 (3)2.八数码问题形式化描述 (3)3。
解决方案 (4)二、A*算法 (4)1.A＊搜索算法一般介绍 (4)2. A*算法的伪代码 (5)3。
建立合适的启发式 (6)三、算法实现及性能比较 (7)四、算法性能分析 (8)五、结论 (9)六、参考文献 (10)附录 (10)一、8数码问题1。
问题描述八数码问题是指这样一种游戏:将分别标有数字1，2，3,…,8 的八块正方形数码牌任意地放在一块3×3 的数码盘上。
放牌时要求不能重叠。
于是，在3×3 的数码盘上出现了一个空格。
现在要求按照每次只能将与空格相邻的数码牌与空格交换的原则，不断移动该空格方块以使其和相邻的方块互换，直至达到所定义的目标状态.空格方块在中间位置时有上、下、左、右4个方向可移动，在四个角落上有2个方向可移动，在其他位置上有3个方向可移动，问题描述如图1-1所示初始状态过渡状态最终状态图1-1 八数码问题执行过程2.八数码问题形式化描述初始状态：初始状态向量:规定向量中各分量对应的位置，各位置上的数字。
把3×3的棋盘按从左到右，从上到下的顺序写成一个一维向量。
我们可以设定初始状态:〈1，5,2，4，0，3，6，7，8>后继函数：按照某种规则移动数字得到的新向量.例如：〈1,5,2,4,0，3，6，7，8〉 〈1,0,2,4,5，3，6，7，8〉目标测试：新向量是都是目标状态。
即〈1，2，3，4,5，6,7，8，0>是目标状态?路径耗散函数：每次移动代价为1，每执行一条规则后总代价加1。
3。
解决方案该问题是一个搜索问题。
它是一种状态到另一种状态的变换。
要解决这个问题,必须先把问题转化为数字描述.由于八数码是一个3＊3的矩阵，但在算法中不实用矩阵,而是将这个矩阵转化为一个一维数组,使用这个一维数组来表示八数码，但是移动时要遵守相关规则。
八数码问题C语言A星算法详细实验报告含代码
一、实验容和要求八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
例如：(a) 初始状态(b) 目标状态图1 八数码问题示意图请任选一种盲目搜索算法（广度优先搜索或深度优先搜索）或任选一种启发式搜索方法（全局择优搜索，加权状态图搜索，A算法或A* 算法）编程求解八数码问题（初始状态任选）。
选择一个初始状态，画出搜索树，填写相应的OPEN 表和CLOSED表，给出解路径，对实验结果进行分析总结，得出结论。
二、实验目的1. 熟悉人工智能系统中的问题求解过程；2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用；3. 熟悉对八数码问题的建模、求解及编程语言的应用。
三、实验算法A*算法是一种常用的启发式搜索算法。
在A*算法中，一个结点位置的好坏用估价函数来对它进行评估。
A*算法的估价函数可表示为：f'(n) = g'(n) + h'(n)这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值（也称为最小耗费或最小代价），h'(n)是n到目标的最短路经的启发值。
由于这个f'(n)其实是无法预先知道的，所以实际上使用的是下面的估价函数：f(n) = g(n) + h(n)其中g(n)是从初始结点到节点n的实际代价，h(n)是从结点n到目标结点的最佳路径的估计代价。
在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。
用f(n)作为f'(n)的近似，也就是用g(n)代替g'(n)，h(n)代替h'(n)。
这样必须满足两个条件：（1）g(n)>=g'(n)（大多数情况下都是满足的，可以不用考虑），且f必须保持单调递增。
（2）h必须小于等于实际的从当前节点到达目标节点的最小耗费h(n)<=h'(n)。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
八数码问题A*算法的实现及性能分析计算机科学与技术学院专业：计算机科学与技术161210404 杨凯迪目录一、8数码问题 (3)1.问题描述 (3)2.八数码问题形式化描述 (3)3.解决方案 (4)二、A*算法 (4)1.A*搜索算法一般介绍 (4)2. A*算法的伪代码 (5)3. 建立合适的启发式 (6)三、算法实现及性能比较 (7)四、算法性能分析 (8)五、结论 (9)六、参考文献 (10)附录 (10)一、8数码问题1.问题描述八数码问题是指这样一种游戏：将分别标有数字1，2，3，…，8 的八块正方形数码牌任意地放在一块3×3 的数码盘上。
放牌时要求不能重叠。
于是，在3×3 的数码盘上出现了一个空格。
现在要求按照每次只能将与空格相邻的数码牌与空格交换的原则，不断移动该空格方块以使其和相邻的方块互换，直至达到所定义的目标状态。
空格方块在中间位置时有上、下、左、右4个方向可移动，在四个角落上有2个方向可移动，在其他位置上有3个方向可移动，问题描述如图1-1所示初始状态过渡状态最终状态图1-1 八数码问题执行过程2.八数码问题形式化描述初始状态：初始状态向量：规定向量中各分量对应的位置，各位置上的数字。
把3×3的棋盘按从左到右，从上到下的顺序写成一个一维向量。
我们可以设定初始状态：<1,5,2,4,0,3,6,7,8>后继函数：按照某种规则移动数字得到的新向量。
例如：<1,5,2,4,0,3,6,7,8> <1,0,2,4,5,3,6,7,8>目标测试：新向量是都是目标状态。
即<1,2,3,4,5,6,7,8,0>是目标状态？路径耗散函数：每次移动代价为1，每执行一条规则后总代价加1。
3.解决方案该问题是一个搜索问题。
它是一种状态到另一种状态的变换。
要解决这个问题，必须先把问题转化为数字描述。
由于八数码是一个3*3的矩阵，但在算法中不实用矩阵，而是将这个矩阵转化为一个一维数组，使用这个一维数组来表示八数码，但是移动时要遵守相关规则。
(1) 可用如下形式的规则来表示数字通过空格进行移动：<a1,a2,a3,a4,a5,a6,a7,a8,a9>→<b1,b2,b3,b4,b5,b6,b7,b8,b9>(2)共24条移动规则，对应与每个位置的移动规则。
(3)搜索顺序举例：1) 优先移动行数小的棋子(数字)2) 同一行中优先移动列数大的棋子(4)约束规则：不使离开既定位置的数字数增加八数码的节点扩展应当遵循棋子的移动规则。
按规则，每一次可以将一个与空格相邻的棋子移动到空格中，实际上也可以看做空格的相反方向移动。
空格的移动方向可以是上下左右，当然不能出边界。
棋子的位置，也就是保存状态的数组元素的下标，空格移动后，相应位置发生变化，在不移出边界的条件下，空格向右，下，左，上移动后，新位置是原位置分别加上1,3，-1，-3。
在这里，空格可以用任意数字表示。
操作本文用u(up) r(right) d(down) l(left) 分别表示空格的向上向右向下向左四个操作。
经分析，8数码问题的搜索策略共有：1.广度优先搜索、2.深度优先搜索、3.有界深度优先搜索、4.最好优先搜索、5.局部择优搜索，等等。
其中广度优先搜索法是可采纳的，有界深度优先搜索法是不完备的，最好优先和局部择优搜索法是启发式搜索法。
本实验采用启发式A*搜索算法来实现。
二、A*算法1.A*搜索算法一般介绍A* 算法实际是一种启发式搜索，所谓启发式搜索，就是利用一个估价函数评估每次的的决策的价值，决定先尝试哪一种方案，这样可以极大的优化普通的广度优先搜索。
一般来说，从出发点(A)到目的地(B)的最短距离是固定的，我们可以写一个函数judge() 估计 A 到 B 的最短距离，如果程序已经尝试着从出发点 A 沿着某条路线移动到了 C 点, 那么我们认为这个方案的 A B 间的估计距离为 A 到 C 实际已经行走了的距离H 加上用judge() 估计出的 C 到B 的距离。
如此，无论我们的程序搜索展开到哪一步，都会算出一个评估值，每一次决策后，将评估值和等待处理的方案一起排序，然后挑出待处理的各个方案中最有可能是最短路线的一部分的方案展开到下一步，一直循环到对象移动到目的地，或所有方案都尝试过却没有找到一条通向目的地的路径则结束。
A*算法是一个可采纳的最好优先算法。
A*算法的估价函数可表示为：f'(n) = g'(n) + h'(n)这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值，h'(n)是n到目标的最断路经的启发值。
由于这个f'(n)其实是无法预先知道的，所以我们用前面的估价函数f(n)做近似。
g(n)代替g'(n)，但g(n)>=g'(n)才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h'(n)，但h(n)<=h'(n)才可。
可以证明应用这样的估价函数是可以找到最短路径的，也就是可采纳的。
2. A*算法的伪代码创建两个表，OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。
算起点的估价值;将起点放入OPEN表;while(OPEN!=NULL){从OPEN表中取估价值f最小的节点n;if(n节点==目标节点){break;}for(当前节点n 的每个子节点X){算X的估价值;if(X in OPEN){if( X的估价值小于OPEN表的X估价值){把n设置为X的父亲;更新OPEN表中的估价值; //取最小路径的估价值}}if(X inCLOSE) {if( X的估价值小于CLOSE表的X估价值){把n设置为X的父亲;将该节点从close表中除去把X节点放入OPEN //取最小路径的估价值}}if(X not inboth){把n设置为X的父亲;求X的估价值;并将X插入OPEN表中; //升序排列open}}//end for将n节点插入CLOSE表中;按照估价值将OPEN表中的节点排序; //实际上是比较OPEN表内节点f 的大小，从最小路径的节点向下进行。
}//end while(OPEN!=NULL)保存路径，即从终点开始，每个节点沿着父节点移动直至起点，这就是你的路径；3. 建立合适的启发式A*算法有个计算公式f(x) = g(x)+h(x)其中g(x)为从起始状态到当前状态所消耗的步数，h(x)为一个启发值，估算从当前状态到目标状态所需的步数，一般h(x)小于等于实际需要步数为好，这样不会将最优解忽略，因为h(x)和解空间有一些关系，如果h(x)设置的比实际需要的步数多，那么解空间就有可能将最优解忽略。
举个例子吧，宽度优先搜索就是h(x)=0带来的效果，深度优先搜索就是g(x)=0带来的效果，不过h(x)距离h*(x)[实际需要的步数]的程度不能过大，否则h(x)就没有过强的区分能力，算法效率并不会很高。
对一个好的h(x)的评价是：h(x)在h*(n)[实际需要的步数]的下界之下，并且尽量接近h*(n)[实际需要的步数].那么8数码问题g(x) 为经过上下左右移动空格附近的数字来得到新状态所需步数，h(x)为当前状态与目标状态的距离，就是所有不在目标位置的数字总和，必然小于h*(x)三、算法实现及性能比较这里通过c++语言来实现各种排序算法（源码见附录），程序运行环境为windows 7，所用编译器为vs2013。
实验分别以不同的初始棋盘和相同的目标棋盘为例进行测试。
初始数码棋盘1：2 0 3 1 4 6 7 5 8初始数码棋盘2：2 4 3 0 6 8 1 7 5初始数码棋盘3：2 3 7 6 4 8 1 0 5初始数码棋盘4：3 2 4 5 0 7 8 1 6初始数码棋盘5：4 0 3 2 6 8 1 7 5初始数码棋盘6：1 4 3 5 7 0 2 6 8初始数码棋盘7：4 6 3 2 8 5 1 0 7目标数码棋盘：1 2 3 4 5 6 7 8 0实验部分结果如图3-1：图3-1.测试结果四、算法性能分析在测试中我们根据不同的初始数码状态相同的目标数码状态，产生不同的移动步骤，并给出了其步数和运行时间（单位ms）。
表1为不同的初始数码状态相同的目标数码状态测试后得到的运行时间数据。
表2为不同的初始数码状态相同的目标数码状态能否的到正确的步骤与否的数据。
表1 步数和运行时间（单位ms ）表2 能否得到正确步骤为了直观起见，根据实验数据画出不同的初始数码状态相同的目标数码状态下时间随步数的变化趋势图如图3-2所示：50010001500200025003000T i m e (m s )Steps图3-2时间随步数的变化趋势图根据实验数据表2，我们可得到该算法得到正确步骤路径的概率为：71.42%。
五、结论 最后我们得出结论： 时间性能上，算法所需时间随步数的增加而逐渐呈增加趋势，但并不是线性增长。
部分时间不随移动步数变化。
该算法能得到正确的解概率约为71.42%六、参考文献1．《Artificial intelligence :;a modern approach 人工智能: 一种现代方法》作者：Russell, Stuart J. 出版社：清华大学出版社附录#include<iostream>#include<time.h>#include<windows.h>#include<vector>#include<cmath>using namespace std;struct node{int a[3][3]; //存放矩阵int father; //父节点的位置int gone; //是否遍历过,1为是,0为否int fn; //评价函数的值int x,y; //空格的坐标int deep; //节点深度};vector<node> store; //存放路径节点int mx[4]={-1,0,1,0};int my[4]={0,-1,0,1}; //上下左右移动数组int top; //当前节点在store中的位置bool check(int num) //判断store[num]节点与目标节点是否相同,目标节点储存在store[0]中{for(int i=0;i<3;i++){for(int j=0;j<3;j++){if(store[num].a[i][j]!=store[0].a[i][j])return false;}}return true;}bool search(int num) //判断store[num]节点是否已经扩展过 ,没有扩展返回true {int pre=store[num].father; //pre指向store[num]的父节点位置bool test=true;while(!pre){ //循环直到pre为0,既初始节点for(int i=0;i<3;i++){for (int j=0;j<3;j++){if(store[pre].a[i][j]!=store[num].a[i][j]){test=false;break;}}if(test==false) break;}if(test==true) return false;pre=store[pre].father; //pre继续指向store[pre]父节点位置}return true;}void print(int num) //打印路径,store[num]为目标节点{vector<int> temp; //存放路径int pre=store[num].father;temp.push_back(num);while(pre!=0){ //从目标节点回溯到初始节点temp.push_back(pre);pre=store[pre].father;}cout<<endl;cout<<"*********数码移动步骤*********"<<endl;int mm=1; //步数for(int m=temp.size()-1;m>=0;m--){cout<<"---第"<<mm<<"步---："<<endl;for(int j=0;j<3;j++){cout<<store[temp[m]].a[i][j]<<" ";}cout<<endl;}mm++;cout<<endl;}cout<<"所需步数为: "<<store[num].deep<<endl;return;}int get_fn(int num) //返回store[num]的评价函数值{int fn_temp=0; //评价函数值bool test=true;for(int i=0;i<3;i++){ //当找到一个值后,计算这个值位置与目标位置的距离差,test置为false后继续寻找下一个值for(int j=0;j<3;j++){test=true;for(int k=0;k<3;k++){for(int l=0;l<3;l++){if((store[num].x!=i||store[num].y!=j)&&store[num].a[i][j]==store[0].a[k][l]){ //寻值时排除空格位fn_temp=fn_temp+abs(i-k)+abs(j-l);test=false;}if(test==false) break;}if(test==false) break;}}}fn_temp=fn_temp+store[num].deep; //加上节点深度return fn_temp;}void kongxy(int num) //获得空格坐标{for(int i=0;i<3;i++){for(int j=0;j<3;j++){if(store[num].a[i][j]==0){store[num].x=i;store[num].y=j;}}return;}int main(){cout<<"-----------A*算法解决8数码问题------------"<<endl;while(true){store.clear(); //清空storevector<int> open; //建立open表int i,j,m,n,f;int min; //store[min]储存fn值最小的节点int temp;bool test;top=1; //当前节点在store的位置,初始节点在store[1]int target[9];int begin[9]; //储存初始状态和目标状态,用于判断奇偶int t1=0,t2=0; //初始状态和目标状态的奇偶序数node node_temp;store.push_back(node_temp);store.push_back(node_temp); //用于创建store[0]和store[1],以便下面使用cout<<"请输入初始数码棋盘状态,0代表空格："<<endl; //输入初始状态,储存在store[1]中test=false;while(test==false){f=0;for(i=0;i<3;i++){for(j=0;j<3;j++){cin>>temp;store[1].a[i][j]=temp;begin[f++]=temp;}}test=true;for(i=0;i<8;i++){ //检查是否有重复输入,若有则重新输入for(j=i+1;j<9;j++){if(begin[i]==begin[j]){test=false;}}if(test==false) break;}if(test==false) cout<<"输入重复,请重新输入:"<<endl;}kongxy(1); //找出空格的坐标cout<<"请输入目标数码棋盘状态,0代表空格： "<<endl; //输入目标状态,储存在store[0]中test=false;while(test==false){f=0;for(i=0;i<3;i++){for(j=0;j<3;j++){cin>>temp;store[0].a[i][j]=temp;target[f++]=temp;}}test=true;for(i=0;i<8;i++){ //检查是否有重复输入,若有则重新输入for(j=i+1;j<9;j++){if(target[i]==target[j]){test=false;break;}}if(test==false) break;}if(test==false){cout<<"输入重复,请重新输入:"<<endl;continue; //若重复,重新输入}for(i=0;i<9;i++){ //检查目标状态与初始状态是否匹配test=false;for(j=0;j<9;j++){if(begin[i]==target[j]){test=true;break;}if(test==false) break;}if(test==false) cout<<"输入与初始状态不匹配,请重新输入:"<<endl;}for(i=1;i<9;i++){ //判断奇偶序数是否相同,若不相同则无法找到路径for(j=1;i-j>=0;j++){if(begin[i]>begin[i-j]){if(begin[i-j]!=0) t1++;}}}for(i=1;i<9;i++){for(j=1;i-j>=0;j++){if(target[i]>target[i-j]){if(target[i-j]!=0) t2++;}}}if(!(t1%2==t2%2)){cout<<"无法找到路径."<<endl;cout<<endl;//system("pause");//return 0;continue;}LARGE_INTEGER Freg;LARGE_INTEGER Count1,Count2;QueryPerformanceFrequency(&Freg);QueryPerformanceCounter(&Count1);//获取时间Count1double d;store[1].father=0; //初始化参数store[1].gone=0;store[1].deep=0; //初始节点的父节点为0store[1].fn=get_fn(1);if(check(1)){ //判断初始状态与目标状态是否相同print(1);//system("pause");//return 0;cout<<endl;continue;}open.push_back(1); //把初始状态在store中的位置数压入open表中while(!open.empty()){ //当open表不为空时,开始寻找路径if(check(top)) break;min=top;int i_min=0;for(i=0;i<open.size();i++){ //遍历open表中元素,找出store中fn值最小的节点if(store[open[i]].fn<=store[min].fn&&store[open[i]].gone==0){min=open[i];i_min=i;}}store[min].gone=1;open.erase(open.begin()+i_min); //把最小节点标记遍历过,并从open表中删除m=store[min].x;n=store[min].y; //空格坐标for(f=0;f<4;f++){ //上下左右移动空格i=m+mx[f];j=n+my[f];if(i>=0&&i<=2&&j>=0&&j<=2){ //当变换后的空格坐标在矩阵中时,开始移动top++;store.push_back(store[min]); //把store[min]压入store中成为新增节点,位置为store[top]store[top].father=min; //新增节点的父节点为minstore[top].gone=0; //新增节点未被访问store[top].deep=store[min].deep+1; //新增节点的深度为父节点深度+1temp=store[top].a[m][n]; //交换空格与相邻数字store[top].a[m][n]=store[top].a[i][j];store[top].a[i][j]=temp;store[top].x=i; //移动后的空格坐标store[top].y=j;store[top].fn=get_fn(top); //移动后的fn值open.push_back(top); //把top压入open表中if(check(top)){ //检查是否到达目标print(top);//system("pause");//return 0;break;}if(search(top)==false){ //检查新增节点是否被访问过,若访问过,则删除此节点top--;store.pop_back();open.pop_back();}}}}QueryPerformanceCounter(&Count2);//获取时间Count2d=(double)(Count2.QuadPart-Count1.QuadPart)/(double)Freg.QuadPart*1000.0;//计算时间差，d的单位为ms.cout<<"算法时间为为"<<d<<" ms."<<endl;cout<<endl;}return 0;system("pause");}。