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*算法求解框图：●分析估价函数对搜索算法的影响：估价函数就是评价函数，它用来评价子结点的好坏，因为准确评价是不可能的，所以称为估值。
八数码问题C语言A星算法详细实验报告含代码
八数码问题C语言A星算法详细实验报告含代码Document serial number【UU89WT-UU98YT-UU8CB-UUUT-UUT108】一、实验内容和要求八数码问题：在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必须保持单调递增。
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)# 如果该节点是目标节点，则搜索结束；否则，将扩展出来的新节点加入优先队列中。
基于启发式搜索算法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，并从
A星八数码求解资料讲解
friend bool operator <(const P &a,const P &b){//按f(n)=g(n)+h(n)大小排序
return a.d+a.w>b.d+b.w; //最大堆
}
}p;
const int N=3;//棋盘大小
const string t="123405678";//目标状态
估价函数的形式可定义如下式所示：
f(n)=g(n)+h(n)其中n是被评价的当前节点。f(n)、g(n)和h(n)分别表示是对f*(n)、g*(n)和h*(n)3个函数值的估计值。
利用估价函数f(n)=g(n)+h(n)来排列open表节点顺序的图搜索算法称为算法A。在A算法中，如果对所有的x，
h(x)<=h*(x)成立，则称好h(x)为h*(x)的下界，它表示某种偏于保守的估计。采用h*(x)的下界h(x)为启发函数的A算法，称为A*算法。
而第二成节点只有654个，比第一种少了很多：
原因分析：
通过实验结果也说明了估计函数对启发式搜索算法的重要影响，因为第二种估价函数p(n)是节点与目标节点相比所需移动次数的总和，与第一种估价函数w(n)（只考虑错误位数）相比，p(n)不仅考虑了错位信息，还考虑了错位的距离，比w(n)更完美，所以它的执行效率更高。
}
}
}
if(flag%2!=0)
return -1;//搜索失败
}
6源程序（采用上述中更高效的第二种估价函数）。
//************************************
//*八数码问题
基于A星算法的8数码问题求解方案设计（1）
基于A星算法的8数码问题求解⽅案设计（1）⼀、问题描述8数码问题⼜称9宫问题，与游戏“华容道”类似。
意在给定的33棋格的8个格⼦内分别放⼀个符号，符号之间互不相同，余下的⼀格为空格。
并且通常把8个符号在棋格上的排列顺序称作8数码的状态。
开始时，规则给定⼀个初始状态和⼀个⽬标状态，并要求被试者对棋格内的符号经过若⼲次移动由初始状态达到⽬标状态，这个过程中只有空格附近的符号可以朝空格的⽅向移动，且每次只能移动⼀个符号。
为⽅便编程和表⽰，本⽂中8个格⼦内的符号分别取1—8的8个数字表⽰，空格⽤0表⽰。
并给定8数码的初始状态和⽬标状态分别如图1、2所⽰。
图1 初始状态图2 ⽬标状态则要求以图1为初始状态，通过交换0和0的上、下、左、右四个⽅位的数字（每次只能和其中⼀个交换），达到图2所⽰⽬标状态。
⼆、实验⽬的熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利⽤A*算法求解N数码难题，理解求解流程和搜索顺序。
三、实验任务1）实现类似于如图所⽰N数码难题演⽰程序。
2）⽤你所熟悉的程序语⾔实现，可以B/S实现，也可以C/S实现四、算法设计根据任务要求，本⽂采⽤A*搜索算法。
但要在计算机上通过编程解决该问题，还应当解决该问题在计算机上表⽰的⽅式，并设计合适的启发函数，以提⾼搜索效率。
①状态的表⽰在A*算法中，需要⽤到open表和closed表，特别是在open表中，待扩展节点间有很严格的扩展顺序。
因此在表⽰当前状态的变量中，必须要有能指向下⼀个扩展节点的指针，以完成对open表中元素的索引。
从这⼀点上看，open表中的元素相互间即构成了⼀个线性表，因此初步选定使⽤结构体表⽰问题的状态。
如图3所⽰，表⽰问题的结构体包括表⽰当前节点状态的DATA和指向open 表中下⼀个待扩展节点的指针NEXT。
图3 结构体现在进⼀步考虑DATA中包括的内容：如图1、2所⽰，8数码问题的提出是以⼀个33数表表⽰的，因此本⽂中采⽤⼀个33的⼆维数组s[3][3]表⽰当前状态的具体信息。
A-star-算法-八数码问题-C++-报告+代码+详细注释1
二、程序运行测试A*算法求解八数码问题一、详细设计说明1.评价函数以当前状态下各将牌到目标位置的距离之和作为节点的评价标准。
距离的定义为: “某将牌行下标与目标位置行下标之差的绝对值 + 列下标与目标位置列下标之差的绝对值”。
距离越小, 该节点的效果越好。
某个状态所有将牌到目标位置的距离之和用“h值”表示。
2.主要函数2.1countH（state & st）;countH函数功能是计算st状态的h值。
2.2计算过程中将会用到rightPos数组, 数组里记录的是目标状态下, 0~9每个将牌在九宫格里的位置（位置 = 行下标 * 3 + 列下标）。
2.3f（state * p）;f()=h()+level2.4look_up_dup(vector<state*> & vec, state * p);2.5在open表或close表中, 是否存在指定状态p, 当找到与p完全相等的节点时, 退出函数。
2.6search(state & start)；在open表不为空时, 按f值由小到大对open表中元素进行排序。
调用findZero()函数找到0值元素的位置。
空格可以向上下左右四个方向移动, 前提是移动后不能越过九宫格的边界线。
确定某方向可走后, 空格移动一步, 生成状态p’。
2.7此时, 检查open表中是否已有p’, 若有, 更新p’数据；检查close表中是否已有p’, 若有, 将p’从close表中删除, 添加到open表中。
2.8重复的执行这个过程, 直到某状态的h值为零。
2.9dump_solution(state * q)；在终端输出解路径。
// A*算法八数码问题#include"stdafx.h"#include<iostream>#include<vector>#include<time.h>#include<algorithm>using namespace std;const int GRID = 3; //Grid表示表格的行数(列数), 这是3*3的九宫格int rightPos[9] = { 4, 0, 1, 2, 5, 8, 7, 6, 3 };//目标状态时, 若p[i][j]=OMG,那么3*i+j = rightPos[OMG]struct state{int panel[GRID][GRID];int level; //记录深度int h;state * parent;state(int level) :level(level){}bool operator == (state & q){//判断两个状态是否完全相等（对应位置元素相等）, 完全相等返回true,否则返回falsefor (int i = 0; i<GRID; i++){for (int j = 0; j<GRID; j++){if (panel[i][j] != q.panel[i][j])return false;}}return true;}state & operator = (state & p){ //以状态p为当前状态赋值, 对应位置元素相同for (int i = 0; i<GRID; i++){for (int j = 0; j<GRID; j++){panel[i][j] = p.panel[i][j];}}return *this;}};void dump_panel(state * p){ //将八数码按3*3矩阵形式输出for (int i = 0; i<GRID; i++){for (int j = 0; j<GRID; j++)cout << p->panel[i][j] << " ";cout << endl;}}int countH(state & st){ //给定状态st, 计算它的h值。
采用A算法解决八数码问题
人工智能实验一报告题目：采用A*算法解决八数码问题姓名： XXX学号： 10S003028专业：计算机科学与技术提交日期： 2011-05-04目录1问题描述........................................................................................................................... - 2 -1.1待解决问题的解释............................................................................................... - 2 -1.2问题的搜索形式描述............................................................................................ - 2 -1.3解决方案介绍（原理）........................................................................................ - 3 -2算法介绍........................................................................................................................... - 4 -2.1A*搜索算法一般介绍............................................................................................ - 4 -2.2 算法伪代码........................................................................................................... - 4 -3算法实现........................................................................................................................... - 5 -3.1 实验环境与问题规模........................................................................................... - 5 -3.2 数据结构............................................................................................................... - 5 -3.3 实验结果............................................................................................................... - 6 -3.4系统中间及最终输出结果.................................................................................... - 6 -4参考文献........................................................................................................................... - 7 - 5附录—源代码及其注释................................................................................................... - 7 -1问题描述所谓八数码问题是指这样一种游戏：将分别标有数字1，2，3，…，8 的八块正方形数码牌任意地放在一块3×3 的数码盘上。
人工智能实验一_八数码问题
用A*算法解决八数码问题1 问题描述1.1 待解决问题的解释八数码游戏（八数码问题）描述为：在3×3组成的九宫格棋盘上，摆有八个将牌，每一个将牌都刻有1-8八个数码中的某一个数码。
棋盘中留有一个空格，允许其周围的某一个将牌向空格移动，这样通过移动将牌就可以不断改变将牌的布局。
这种游戏求解的问题是：给定一种初始的将牌布局或结构（称初始状态）和一个目标的布局（称目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。
1.2 问题的搜索形式描述（4要素）初始状态：8个数字将牌和空格在九宫格棋盘上的所有格局组成了问题的状态空间。
其中，状态空间中的任一种状态都可以作为初始状态。
后继函数：通过移动空格（上、下、左、右）和周围的任一棋子一次，到达新的合法状态。
目标测试：比较当前状态和目标状态的格局是否一致。
路径消耗：每一步的耗散值为1，因此整个路径的耗散值是从起始状态到目标状态的棋子移动的总步数。
1.3 解决方案介绍（原理）对于八数码问题的解决，首先要考虑是否有答案。
每一个状态可认为是一个1×9的矩阵，问题即通过矩阵的变换，是否可以变换为目标状态对应的矩阵？由数学知识可知，可计算这两个有序数列的逆序值，如果两者都是偶数或奇数，则可通过变换到达，否则，这两个状态不可达。
这样，就可以在具体解决问题之前判断出问题是否可解，从而可以避免不必要的搜索。
如果初始状态可以到达目标状态，那么采取什么样的方法呢？常用的状态空间搜索有深度优先和广度优先。
广度优先是从初始状态一层一层向下找，直到找到目标为止。
深度优先是按照一定的顺序前查找完一个分支，再查找另一个分支，以至找到目标为止。
广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。
这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不预测的情况下就不可取了。
他的效率实在太低，甚至不可完成。
由于八数码问题状态空间共有9!个状态，对于八数码问题如果选定了初始状态和目标状态，有9!/2个状态要搜索，考虑到时间和空间的限制，在这里采用A*算法作为搜索策略。
用A算法解八数码问题
用A*算法解八数码问题1.启发式搜索广度优先搜索和双向广度优先搜索都属于盲目搜索，这在状态空间不大的情况下是很合适的算法，可是当状态空间十分庞大时，它们的效率实在太低，往往都是在搜索了大量无关的状态结点后才碰到解答，甚至更本不能碰到解答。
搜索是一种试探性的查寻过程，为了减少搜索的盲目性引，增加试探的准确性，就要采用启发式搜索了。
所谓启发式搜索就是在搜索中要对每一个搜索的位置进行评估，从中选择最好、可能容易到达目标的位置，再从这个位置向前进行搜索，这样就可以在搜索中省略大量无关的结点，提高了效率。
2.A*算法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)（1）g(n)>=g'(n)的近似，也就是用g(n)代替g'(n)，h(n)代替h'(n)。
这样必须满足两个条件：（大多数情况下都是满足的，可以不用考虑），且f必须保持单调递增。
（2）h必须小于等于实际的从当前节点到达目标节点的最小耗费h(n)<=h'(n)。
第二点特别的重要。
可以证明应用这样的估价函数是可以找到最短路径的。
3.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星算法
/* A*算法伪代码算法的功能：产生8数码问题的解(由初始状态到达目标状态的过程）输入：初始状态，目标状态输出：从初始状态到目标状态的一系列过程算法描述：Begin：读入初始状态和目标状态，并计算初始状态评价函数值f；根据初始状态和目标状态，判断问题是否可解；If(问题可解)把初始状态加入open表中；While（未找到解&&状态表非空）①在open表中找到评价值最小的节点，作为当前结点；②判断当前结点状态和目标状态是否一致，若一致，跳出循环；否则跳转到③；③对当前结点，分别按照上、下、左、右方向移动空格位置来扩展新的状态结点，并计算新扩展结点的评价值f并记录其父节点；④对于新扩展的状态结点，判断其是否重复，若不重复把其加入到open表中；⑤把当前结点从open表中移除；End whileEnd if输出结果；End程序中我们假设空格无论往那个方向移动一步的代价都是1，取f(n) = g(n) + h(n)为估价函数其中f(n) 是节点n的估价函数，g(n)是在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价，由错位数算出。
在VC6.0下运行成功*/#include "iostream"#include <time.h>#include <stdio.h>#include <dos.h>#include <conio.h>using namespace std;static int target[9]; //全局静态变量，表明目标状态//class definitionclasseight_num{private:intnum[9]; //定义八数码的初始态intnot_in_position_num; //定义不在正确位置的八数码的个数intdeapth; //定义了搜索的深度（当前节点离起始节点的距离）inteva_function; //评价函数f的值，每次选取最小的进行下一步的扩展public:eight_num* parent; //指向节点的父节点eight_num* leaf_next; //指向open表的下一个节点eight_num* leaf_pre; //指向open 表的前一个节点eight_num(intinit_num[9]); //初始状态的构造函数eight_num(int num1,int num2,int num3,int num4,int num5,int num6,int num7,int num8,int num9){num[0]=num1;num[1]=num2;num[2]=num3;num[3]=num4;num[4]=num5;num[5]=num6;num[6]=num7;num[7]=num8;num[8]=num9;}eight_num(void){for (int i=0;i<9;i++)num[i]=i;}void cul_para(void); //计算启发函数g(n)的值void get_numbers_to(intother_num[9]); //复制当前节点状态到一个另数组中intget_nipn(void){returnnot_in_position_num;}intget_deapth(void){returndeapth;}intget_evafun(void){returneva_function;}voidset_num(intother_num[9]);void show(void); //显示当前节点的状态eight_num& operator=(eight_num&);eight_num& operator=(intother_num[9]);int operator==(eight_num&);int operator==(intother_num[9]);};//计算启发函数g(n)的值voideight_num::cul_para(void){int i;inttemp_nipn=0;for (i=0;i<9;i++)if (num[i]!=target[i])temp_nipn++;not_in_position_num=temp_nipn;if (this->parent==NULL)deapth=0;elsedeapth=this->parent->deapth+1;eva_function=not_in_position_num+deapth; }//构造函数1eight_num::eight_num(intinit_num[9]){for (int i=0;i<9;i++)num[i]=init_num[i];}//显示当前节点的状态voideight_num::show(){cout<<num[0];cout<<" ";cout<<num[1];cout<<" ";cout<<num[2];cout<<"\n";cout<<num[3];cout<<" ";cout<<num[4];cout<<" ";cout<<num[5];cout<<"\n";cout<<num[6];cout<<" ";cout<<num[7];cout<<" ";cout<<num[8];cout<<"\n";}//复制当前节点状态到一个另数组中voideight_num::get_numbers_to(intother_num[9]){for (int i=0;i<9;i++)other_num[i]=num[i];}//设置当前节点状态(欲设置的状态记录的other数组中) voideight_num::set_num(intother_num[9]){for (int i=0;i<9;i++)num[i]=other_num[i];}eight_num&eight_num::operator=(eight_num& another_8num) {for (int i=0;i<9;i++)num[i]=another_8num.num[i];not_in_position_num=another_8num.not_in_position_num;deapth=another_8num.deapth+1;eva_function=not_in_position_num+deapth;return *this;}eight_num&eight_num::operator=(intother_num[9]){for (int i=0;i<9;i++)num[i]=other_num[i];return *this;}inteight_num::operator==(eight_num& another_8num){int match=1;for (int i=0;i<9;i++)if(num[i]!=another_8num.num[i]){match=0;break;}if (match==0)return 0;elsereturn 1;}inteight_num::operator==(intother_num[9]){int match=1;for (int i=0;i<9;i++)if(num[i]!=other_num[i]){match=0;break;}if (match==0)return 0;elsereturn 1;}//class definition over 类定义结束//空格向上移intmove_up(intnum[9]){for (int i=0;i<9;i++)if (num[i]==0)break;if (i<3)return 0;else{num[i]=num[i-3];num[i-3]=0; //两个数互换return 1;}}//空格向下移intmove_down(intnum[9]){for (int i=0;i<9;i++)if (num[i]==0)break;if (i>5)return 0;{num[i]=num[i+3];num[i+3]=0;return 1;}}//空格向左移intmove_left(intnum[9]){for (int i=0;i<9;i++)if (num[i]==0)break;if (i==0||i==3||i==6)return 0;else{num[i]=num[i-1];num[i-1]=0;return 1;}}//空格向右移intmove_right(intnum[9]){for (int i=0;i<9;i++)if (num[i]==0)break;if (i==2||i==5||i==8)return 0;else{num[i]=num[i+1];num[i+1]=0;return 1;}}//判断可否解出inticansolve(intnum[9],int target[9]) {inti,j;intcount_num,count_target;for (i=0;i<9;i++)for (j=0;j<i;j++)if(num[j]<num[i]&&num[j]!=0)count_num++; //求逆序数if(target[j]<target[i]&&target[j]!=0)count_target++;}if((count_num+count_target)%2 == 0)return 1;elsereturn 0;}//判断有无重复int existed(intnum[9],eight_num *where){eight_num *p;for(p=where;p!=NULL;p=p->parent)if(*p==num)return 1; //有重复return 0;}//寻找估价函数最小的叶子节点eight_num* find_OK_leaf(eight_num* start){eight_num *p,*OK;p=OK=start;int min=start->get_evafun();for(p=start;p!=NULL;p=p->leaf_next)if(min>p->get_evafun()){OK=p;min=p->get_evafun();}return OK;}//主函数开始int main(void){double time;clock_tStart,Finish; //clock_t和int一个类型，只不过要声明start、Finish //为时钟变量，易于理解intmemery_used=0,step=0;intnum[9];int flag=0; //是否输入错误标志，1表示输入错误int bingo=0;//是否查找成功标志，1表示成功inti,j;cout<<"请输入八数码的目标状态(用0表示空格):\n";for (i=0;i<9;i++){flag=0;cin>>target[i];for(j=0;j<i;j++)if(target[i]==target[j]) //判断输入的数是否有重复flag=1;if (target[i]<0||target[i]>8||flag==1){i--;cout<<"输入错误，请关闭并重新输入!\n";}}cout<<"请输入八数码的初始状态(用0表示空格):\n";for (i=0;i<9;i++){flag=0;cin>>num[i];for(j=0;j<i;j++)if(num[i]==num[j]) //判断输入的数是否有重复flag=1;if (num[i]<0||num[i]>8||flag==1){i--;cout<<"输入错误，请关闭并重新输入!\n";}}eight_num S(num),Target(target);S.parent=S.leaf_next=S.leaf_pre=NULL;S.cul_para();memery_used++;cout<<"现在初始状态为:\n";S.show();cout<<"目标状态为:\n";Target.show();if(!icansolve(num,target)){cout<<"No one can solve it!\n";exit(0);//cin>>i;//return 1;}Start=clock( );eight_num *OK_leaf=&S,*leaf_start=&S,*new_8num,*p; while(OK_leaf!=NULL&&bingo!=1){OK_leaf=find_OK_leaf(leaf_start);if(*OK_leaf==Target){bingo=1; //判断是否达到目标状态break;}p=OK_leaf->leaf_pre;OK_leaf->get_numbers_to(num);if(move_up(num)&&!existed(num,OK_leaf)){new_8num=new eight_num;new_8num->set_num(num);new_8num->parent=OK_leaf;new_8num->cul_para();new_8num->leaf_pre=p;if(p==NULL)leaf_start=new_8num;elsep->leaf_next=new_8num;p=new_8num;memery_used++;}OK_leaf->get_numbers_to(num);if(move_down(num)&&!existed(num,OK_leaf)){new_8num=new eight_num;new_8num->set_num(num);new_8num->parent=OK_leaf;new_8num->cul_para();new_8num->leaf_pre=p;if(p==NULL)leaf_start=new_8num;elsep->leaf_next=new_8num;p=new_8num;memery_used++;}OK_leaf->get_numbers_to(num);if(move_left(num)&&!existed(num,OK_leaf)){new_8num=new eight_num;new_8num->set_num(num);new_8num->parent=OK_leaf;new_8num->cul_para();new_8num->leaf_pre=p;if(p==NULL)leaf_start=new_8num;elsep->leaf_next=new_8num;p=new_8num;memery_used++;}OK_leaf->get_numbers_to(num);if(move_right(num)&&!existed(num,OK_leaf)){new_8num=new eight_num;new_8num->set_num(num);new_8num->parent=OK_leaf;new_8num->cul_para();new_8num->leaf_pre=p;if(p==NULL)leaf_start=new_8num;elsep->leaf_next=new_8num;p=new_8num;memery_used++;}p->leaf_next=OK_leaf->leaf_next;if(OK_leaf->leaf_next!=NULL)OK_leaf->leaf_next->leaf_pre=p;OK_leaf->leaf_next=OK_leaf->leaf_pre=NULL;}Finish=clock( );if(bingo==1){time = (double)(Finish-Start)*1000/CLOCKS_PER_SEC; //计算时间到mseight_num *p;cout<<"搜索过程为：\n";for (p=OK_leaf->parent;p!=NULL;p=p->parent){cout<<"****************************\n";cout<<" ^\n";p->show();// cout<<"****************************\n";step++;}cout<<"\n搜索所用时间: ";cout<<time;cout<<"ms\n";cout<<"搜索所走的总步数: ";cout<<step;cout<<"\n";}elsecout<<"Fail to find!";return 0;}。
人工智能-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*搜索算法性能的影响等。
八数码问题C语言A星算法详细实验报告含代码
一、实验内容和要求八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
例如：图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)。
用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 ) 满足单调限制条件。
A星八数码求解资料讲解
A星⼋数码求解资料讲解A星⼋数码求解实验⼆ A*算法实验I软⼯1303 201326811825 朱镇洋⼀、实验⽬的：熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利⽤A*算法求解N 数码难题，理解求解流程和搜索顺序。
⼆、实验原理：A*算法是⼀种启发式图搜索算法，其特点在于对估价函数的定义上。
对于⼀般的启发式图搜索，总是选择估价函数f 值最⼩的节点作为扩展节点。
因此，f 是根据需要找到⼀条最⼩代价路径的观点来估算节点的，所以，可考虑每个节点n 的估价函数值为两个分量：从起始节点到节点n 的实际代价以及从节点n 到达⽬标节点的估价代价。
三、实验内容： 1 问题描述。
⼋数码问题:在⼀个3×3的⽅阵中放⼊⼋个数码1、2、3、4、5、6、7、8，其中⼀个单元格是空的。
将任意摆放的数码盘（初始状态）逐步摆成某个指定的数码盘的排列（⽬标状态）：2 设计两种不同的估价函数。
w(n) ；w 表⽰不在⽬标位置的节点数h(n)=d(n)+ ；d(n)表⽰深度p(n) ；p 表⽰所有点到其⽬标节点的步数总和1 2 4 3 5 6782 134 567 8起始状态⽬标状态算法流程图：开始将s 与⽬标序列对⽐结束符合Open 表是否为空Yes读取栈顶元素，并删除堆顶元素No对当前结构扩展，根据空格的位置调整序列并存⼊最⼤堆3 在求解8数码问题的A*算法程序中，设置相同的初始状态和⽬标状态，针对不同的估价函数，求得问题的解令初始状态都为：023415687 ⽬标状态为：123405678通过程序运⾏结果我们可以发现，上述两种估价函数中明显第⼆种在算法效率上更具优势，第⼀种估价函数要通过18步才能到达⽬标状态，通过中间变量记录扩展节点和⽣成节点有1062个：⽽第⼆种估价函数只要16步即可到达⽬标状态，也意味着扩展节点和⽣成节点只有654个，⽐第⼀种少了很多：原因分析：通过实验结果也说明了估计函数对启发式搜索算法的重要影响，因为第⼆种估价函数p(n)是节点与⽬标节点相⽐所需移动次数的总和，与第⼀种估价函数w(n)（只考虑错误位数）相⽐，p(n)不仅考虑了错位信息，还考虑了错位的距离，⽐w(n)更完美，所以它的执⾏效率更⾼。
实验三：A星算法求解8数码问题实验讲解
实验三：A*算法求解8数码问题实验一、实验目的熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解N数码难题，理解求解流程和搜索顺序。
二、实验内容1、八数码问题描述所谓八数码问题起源于一种游戏:在一个3×3的方阵中放入八个数码1、2、3、4、5、6、7、8，其中一个单元格是空的。
将任意摆放的数码盘（城初始状态）逐步摆成某个指定的数码盘的排列（目标状态），如图1所示：图1 八数码问题的某个初始状态和目标状态对于以上问题，我们可以把数码的移动等效城空格的移动。
如图1的初始排列，数码7右移等于空格左移。
那么对于每一个排列，可能的一次数码移动最多只有4中，即空格左移、空格右移、空格上移、空格下移。
最少有两种（当空格位于方阵的4个角时）。
所以，问题就转换成如何从初始状态开始，使空格经过最小的移动次数最后排列成目标状态。
2、八数码问题的求解算法盲目搜索宽度优先搜索算法、深度优先搜索算法启发式搜索启发式搜索算法的基本思想是：定义一个评价函数f，对当前的搜索状态进行评估，找出一个最有希望的节点来扩展。
先定义下面几个函数的含义：f*(n)=g*(n)+h*(n) (1)￥式中g*(n)表示从初始节点s到当前节点n的最短路径的耗散值；h*(n)表示从当前节点n到目标节点g的最短路径的耗散值，f*(n)表示从初始节点s经过n到目标节点g的最短路径的耗散值。
评价函数的形式可定义如(2)式所示：f(n)=g(n)+h(n) (2)其中n是被评价的当前节点。
f(n)、g(n)和h(n)分别表示是对f*(n)、g*(n)和h*(n)3个函数值的估计值。
利用评价函数f(n)=g(n)+h(n)来排列OPEN表节点顺序的图搜索算法称为算法A。
在A算法中，如果对所有的x，h(x)<=h*(x) (3)成立，则称好h(x)为h*(x)的下界，它表示某种偏于保守的估计。
采用h*(x)的下界h(x)为启发函数的A算法，称为A*算法。
A星八数码求解教学内容
A星八数码求解实验二 A*算法实验I软工1303 201326811825 朱镇洋一、实验目的：熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解N 数码难题，理解求解流程和搜索顺序。
二、实验原理：A*算法是一种启发式图搜索算法，其特点在于对估价函数的定义上。
对于一般的启发式图搜索，总是选择估价函数f 值最小的节点作为扩展节点。
因此，f 是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点n 的估价函数值为两个分量：从起始节点到节点n 的实际代价以及从节点n 到达目标节点的估价代价。
三、实验内容： 1 问题描述。
八数码问题:在一个3×3的方阵中放入八个数码1、2、3、4、5、6、7、8，其中一个单元格是空的。
将任意摆放的数码盘（初始状态）逐步摆成某个指定的数码盘的排列（目标状态）：2 设计两种不同的估价函数。
w(n) ；w 表示不在目标位置的节点数h(n)=d(n)+ ；d(n)表示深度p(n) ；p 表示所有点到其目标节点的步数总和1 2 4 3 5 6782 134 567 8起始状态目标状态算法流程图：开始将s 与目标序列对比结束符合Open 表是否为空Yes读取栈顶元素，并删除堆顶元素No对当前结构扩展，根据空格的位置调整序列并存入最大堆3 在求解8数码问题的A*算法程序中，设置相同的初始状态和目标状态，针对不同的估价函数，求得问题的解令初始状态都为：023415687 目标状态为：123405678通过程序运行结果我们可以发现，上述两种估价函数中明显第二种在算法效率上更具优势，第一种估价函数要通过18步才能到达目标状态，通过中间变量记录扩展节点和生成节点有1062个：而第二种估价函数只要16步即可到达目标状态，也意味着扩展节点和生成节点只有654个，比第一种少了很多：原因分析：通过实验结果也说明了估计函数对启发式搜索算法的重要影响，因为第二种估价函数p(n)是节点与目标节点相比所需移动次数的总和，与第一种估价函数w(n)（只考虑错误位数）相比，p(n)不仅考虑了错位信息，还考虑了错位的距离，比w(n)更完美，所以它的执行效率更高。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
int f,g;//启发函数中的f和g值
struct Node * next;
struct Node *previous;//保存其父节点
};
int open_N=0; //记录Open列表中节点数目
//八数码初始状态
int inital_s[3][3]={
A*算法求解八数码问题
1、八数码问题描述
所谓八数码问题起源于一种游戏:在一个3×3的方阵中放入八个数码1、2、3、4、5、6、7、8，其中一个单元格是空的。将任意摆放的数码盘（城初始状态）逐步摆成某个指定的数码盘的排列（目标状态），如图1所示
图1八数码问题的某个初始状态和目标状态
对于以上问题，我们可以把数码的移动等效城空格的移动。如图1的初始排列，数码7右移等于空格左移。那么对于每一个排列，可能的一次数码移动最多只有4中，即空格左移、空格右移、空格上移、空格下移。最少有两种（当空格位于方阵的4个角时）。所以，问题就转换成如何从初始状态开始，使空格经过最小的移动次数最后排列成目标状态。
2,8,3,
1,6,4,
7,0,5
};
//八数码目标状态
int final_s[3][3]={
1,2,3,
8,0,4,
7,6,5
};
//------------------------------------------------------------------------
//添加节点函数入口，方法：通过插入排序向指定表添加
评价函数的形式可定义如(2)式所示：
f(n)=g(n)+h(n) (2)
其中n是被评价的当前节点。f(n)、g(n)和h(n)分别表示是对f*(n)、g*(n)和h*(n)3个函数值的估计值。
利用评价函数f(n)=g(n)+h(n)来排列OPEN表节点顺序的图搜索算法称为算法A。在A算法中，如果对所有的x，
//八数码问题的启发函数设计为：f(n)=d(n)+p(n),其中A*算法中的g(n)根据具体情况设计为d(n)，意为n节点的深度，而h(n)设计为p(n)，意为放错的数码与正确的位置距离之和。
//后继结点的获取：数码的移动等效为空格的移动。首先判断空格上下左右的可移动性，其次移动空格获取后继结点。
*如果它已在开启或关闭列表中，用g值为参考检查新的路径是否更好。更低的g值意味着更好的路径。如果这样，就把这一节点的父节点改为BESTNODE，并且重新计算这一节点的f和g值，如果保持开启列表的f值排序，改变之后需要重新对开启列表排序。
d)停止
把目标节点添加到关闭列表，这时候路径被找到，或者没有找到路径，开启列表已经空了，这时候路径不存在。
4.3，保存路径。从目标节点开始，沿着每一节点的父节点移动直到回到起始节点。这就是求得的路径。
5、数据结构
采用结构体来保存八数码的状态、f和g的值以及该节点的父节点；
struct Node{
int s[3][3];//保存八数码状态，0代表空格
int f,g;//启发函数中的f和g值
struct Node * next;
3、A*算法流程图,如图2
4、A*算法总结
4.1，把起始状态添加到开启列表。
4.2，重复如下工作：
a)寻找开启列表中f值最低的节点，我们称它为BESTNOE
b)把它切换到关闭列表中。
c)对相邻的4个节点中的每一个
*如果它不在开启列表，也不在关闭列表，把它添加到开启列表中。把BESTNODE作为这一节点的父节点。记录这一节点的f和g值
//-----------------------------------------------------------------------------
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
//八数码状态对应的节点结构体
struct Node{
图2 A*算法流程图
p(n)，意为放错的数码与正确的位置距离之和。
由于实际情况中，一个将牌的移动都是单步进行的，没有交换拍等这样的操作。所以要把所有的不在位的将牌，移动到各自的目标位置上，至少要移动从他们各自的位置到目标位置的距离和这么多次，所以最有路径的耗散值不会比该值小，因此该启发函数h(n)满足A*算法的条件。
//------------------------------------------------------------------------
void Add_Node( struct Node *head, struct Node *p)
{
struct Node *q;
if(head->next)//考虑链表为空
struct Node *previous;//保存其父节点
};
6、实验结果，如图3所示
图3 A*算法求解八数码问题实验结果
7、源代码
//-----------------------------------------------------------------------------
//代码：利用A*算法求解八数码问题。
{ q = head->next;
if(p->f < head->next->f){//考虑插入的节点值比链表的第一个节点值小
2、八数码问题的求解算法
2.1盲目搜索
宽度优先搜索算法、深度优先搜索算法
2.2启发式搜索
启发式搜索算法的基本思想是：定义一个评价函数f，对当前的搜索状态进行评估，找出一个最有希望的节点来扩展。
先定义下面几个函Biblioteka 的含义：f*(n)=g*(n)+h*(n) (1)
式中g*(n)表示从初始节点s到当前节点n的最短路径的耗散值；h*(n)表示从当前节点n到目标节点g的最短路径的耗散值，f*(n)表示从初始节点s经过n到目标节点g的最短路径的耗散值。
h(x)<=h*(x) (3)
成立，则称好h(x)为h*(x)的下界，它表示某种偏于保守的估计。采用h*(x)的下界h(x)为启发函数的A算法，称为A*算法。
针对八数码问题启发函数设计如下：
f(n)=d(n)+p(n) (4)
其中A*算法中的g(n)根据具体情况设计为d(n)，意为n节点的深度，而h(n)设计为