人工智能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*算法的思想，能够更快的求解出最优解。
人工智能九宫格重移(搜索)
人工智能九宫格重移——搜索1.问题描述：八数码问题也称为九宫问题。
在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。
棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。
要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
所谓问题的一个状态就是棋子在棋盘上的一种摆法。
棋子移动后，状态就会发生改变。
解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
2.九宫重移有无答案检查（逆序数）我们把每个9宫格横向展开，如第一个123456789，我们把左边数大于右边数的组数称为这个九宫格的逆序数，显然123456789的逆序数为0；考虑横向平移，那么逆序数的增量为2或0或-2；纵向平移，逆序数的增量为4或0或-4；但147258369的逆序数为奇数。
所以147258369是无解的情况。
由此也可以类推当将9宫格展开后，如果数据序列的逆序数为奇数，则此数据序列对应的九宫格是无解的。
3.BFS算法队列： Queue open = new Queue();存放待扩展的节点List： List<Bfstr> closed = new List<Bfstr>();存放已被扩展过的节点ArrayList map = new ArrayList();//存放答案HashTale： Hashtable table = new Hashtable();构造哈希表以方便查找3.1．BFS算法介绍广度优先搜索算法BFS基本思想：从图中某顶点v出发，逐层对节点进行拓展，并考察是否为目标节点，在第n层节点没有全部扩展并考察前，不对第n+1层节点进行扩展。
对九宫重排问题，即构造广度优先搜索树，从初始状态，利用广度优先搜索算法逐步找到目标状态的节点。
3.2．状态空间表示状态空间用一维数组表示，每个节点存放在Bfstr结构体中的字符now中，从第一行开始从左往右给九宫格标号0……8，字符串now元素下标代表格子位置，而now数组中对应数组的值代表九宫格中存放的数码，用数值9代表空格。
人工智能重排九宫
人工智能课内实验报告——重排九宫问题班级：姓名：学号：重排九宫问题搜索就是利用已知条件（知识）寻求解决问题的办法的过程。
状态空间搜索即为一种重要的搜索策略，其可分为盲目搜索和启发式搜索。
1.实验目的利用状态空间搜索解决实际问题，将理论应用于实践。
加深对概念的理解、知识的掌握，并提高编程能力和动手能力。
2.实验原理1.重排九宫问题在3*3的方格棋盘上放置分别标有数字1，2，3，4，5，6，7，8的八张牌，确定初始状态和目标状态。
可使用的算符有空格左移、空格上移、空格右移、空格下移，即它们只允许把位于空格左、上、右、下边的牌移入空格。
要求寻找从初始状态到目标状态的路径。
2.状态空间搜索状态空间的一般搜索过程：（1）把初始节点S0放入OPEN表，并建立目前只包含S0的图，记为G；（2）检查OPEN表是否为空，若为空则问题无解，退出；（3）把OPEN表的第一个节点取出放入CLOSE表，并记该节点为n；（4）考察节点n是否为目标节点。
若是，则求得了解，退出；（5）扩展节点n，生成一组子节点。
把其中不是节点n先辈的那些子节点记做集合M，并把这些子节点作为节点n的子节点加入G中；（6）针对M中子节点的不同情况，分别进行如下处理：a)对于那些未曾在G中出现过的M成员设置一个指向父节点（即节点n）的指针，并把它们放入OPEN表；（不在OPEN表）b)对于那些先前已经在G中出现过的M成员，确定是否需要修改它指向父节点的指针；（在OPEN表中）c)对于那些先前已在G中出现并且已经扩展了的M成员，确定是否需要修改其后继节点指向父节点的指针；（在CLOSE表中）（7）按某种搜索策略对OPEN表中的节点进行排序；（8）转第2步。
广度优先搜索的基本思想：从初始节点S0开始，逐层地对节点进行扩展，并考察它是否为目标节点。
在第n层的节点没有全部扩展并考察之前，不对第n＋1层的节点进行扩展。
OPEN表中节点总是按照进入的先后顺序排列，先进入的节点排在前面，后进入的排在后面。
人工智能实验设计报告
人工智能九宫格重移——搜索成员：赵春杰 2009210665羊森 2009210653黄鑫 2009210周成兵 2009210664王素娟 20092106441.问题描述：八数码问题也称为九宫问题。
在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。
棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。
要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
所谓问题的一个状态就是棋子在棋盘上的一种摆法。
棋子移动后，状态就会发生改变。
解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
2.九宫重移有无答案检查（逆序数）我们把每个9宫格横向展开，如第一个123456789，我们把左边数大于右边数的组数称为这个九宫格的逆序数，显然123456789的逆序数为0；考虑横向平移，那么逆序数的增量为2或0或-2；纵向平移，逆序数的增量为4或0或-4；但147258369的逆序数为奇数。
所以147258369是无解的情况。
由此也可以类推当将9宫格展开后，如果数据序列的逆序数为奇数，则此数据序列对应的九宫格是无解的。
3.BFS算法队列： Queue open = new Queue();存放待扩展的节点List： List<Bfstr> closed = new List<Bfstr>();存放已被扩展过的节点ArrayList map = new ArrayList();//存放答案HashTale： Hashtable table = new Hashtable();构造哈希表以方便查找3.1．BFS算法介绍广度优先搜索算法BFS基本思想：从图中某顶点v出发，逐层对节点进行拓展，并考察是否为目标节点，在第n层节点没有全部扩展并考察前，不对第n+1层节点进行扩展。
AI怎么制作九宫格照片？AI九宫格效果的两种实现方法
AI怎么制作九宫格照⽚？AI九宫格效果的两种实现⽅法illustrator想要制作九宫格，该怎么制作九宫格照⽚呢？下⾯我们就来看看ai做九宫格艺术照的技巧。
Adobe Illustrator(AI⽮量图⽚制作软件) 2020 v24.3.0.569 安装版
类型：图像处理
⼤⼩：1.46GB
语⾔：简体中⽂
时间：2021-03-14
查看详情
⽅法⼀：剪切蒙版
打开AI软件，同时ctrl+n新建⼀个A4⽂档，如图所⽰。
在⼯具栏中找到矩形⼯具，快捷键是m，并在画布上绘制9个矩形，如图所⽰。
将这9个矩形全选之后，右键--建⽴复合路径，然后ctrl+o打开⼀张图⽚，如图所⽰。
全选9个矩形和图⽚，然后右键--建⽴剪切蒙版即可实现九宫格效果。
注意事项：
注意要将矩形建⽴复合路径
⽅法⼆：切⽚⼯具
双击AI软件的快捷图标，进⼊软件，并打开需要进⾏处理的图⽚；
选择⼯具窗⼝的“切⽚⼯具”；
使⽤切⽚⼯具在图⽚上建⽴9个矩形选区；
单击⽂件-导出-存储为Web所⽤格式；
屏幕右下⾓，选择“选中的切⽚”，选择想要导出的切⽚，设置导出路径，单击储存；
重新置⼊刚刚导出的切⽚图⽚，进⾏适当的排列，这样，九宫格图⽚就绘制成功了！
以上就是AI九宫格效果的两种实现⽅法，希望⼤家喜欢，请继续关注。
人工智能实验报告
人工智能九宫格重移——搜索成员：赵春杰 2009210665羊森 2009210653黄鑫 2009210周成兵 2009210664王素娟 20092106441.问题描述：八数码问题也称为九宫问题。
在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。
棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。
要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
所谓问题的一个状态就是棋子在棋盘上的一种摆法。
棋子移动后，状态就会发生改变。
解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
2.九宫重移有无答案检查（逆序数）我们把每个9宫格横向展开，如第一个123456789，我们把左边数大于右边数的组数称为这个九宫格的逆序数，显然123456789的逆序数为0；考虑横向平移，那么逆序数的增量为2或0或-2；纵向平移，逆序数的增量为4或0或-4；但147258369的逆序数为奇数。
所以147258369是无解的情况。
由此也可以类推当将9宫格展开后，如果数据序列的逆序数为奇数，则此数据序列对应的九宫格是无解的。
3.BFS算法队列： Queue open = new Queue();存放待扩展的节点List： List<Bfstr> closed = new List<Bfstr>();存放已被扩展过的节点ArrayList map = new ArrayList();//存放答案HashTale： Hashtable table = new Hashtable();构造哈希表以方便查找3.1．BFS算法介绍广度优先搜索算法BFS基本思想：从图中某顶点v出发，逐层对节点进行拓展，并考察是否为目标节点，在第n层节点没有全部扩展并考察前，不对第n+1层节点进行扩展。
9宫格问题和15谜问题的求解
9宫格问题和15谜问题的求解9宫格问题和15谜问题的求解 [A*算法]2008-11-15 13:28 /*程序:9宫格问题和15谜的求解算法:A* (A星 / AStar)备注:初次涉及A*算法,用一个简单的例子来感受了一下启发式搜索程序的写法.作为人工智能的算法之一,A*算法不一定能找到最优解,但是能很快的找到解. A*算法的原理不难,就是对状态空间进行估价,然后选择最优的.算法的核心和难点是估价函数的选取和精心设计.很遗憾的是POJ1077"EIGHT"这个程序过不了,而昨天是直接广度搜索过了的. 有人用A*过了那个题目的,说明我的算法实现还很欠缺,有时间再改改.如果程序有什么不妥或者错误,请指正. email:luosiyong@编译环境:Microsoft Visual C++ 6.0 罗泗勇 20081115*/#pragma warning (disable:4786) #include <iostream>#include <string>#include <queue>#include <ctime>#include <set>using namespace std;const int N=4;class Node{public:Node():canberestore(false){} Node(int a[],int c=0,int s=0); bool Check();bool CanRestore() const;bool Complete() const;bool Move(int direction);void Output() const;void CalcCost();string State() const;int cost;int step;string path;private:int block[N*N];int space;bool canberestore;};Node::Node(int a[],int c,int s) //必须经过构造函数检查数据的合法性{memcpy(block,a,sizeof(block));cost=c,step=s;bool exist[N*N]={false}; int i;for(i=0;i<N*N;i++){if(! (block[i]>=1 && block[i]<=N*N)) //方格中的的数据非法{canberestore=false;break;}if(block[i]==N*N)space=i;exist[block[i]-1]=true; } for(i=0;i<N*N;i++){if(! exist[i]) //有些数字没有{canberestore=false;break;}}if(! Check())canberestore=false; }bool Node::Check(){int i,j;int less=0;for(i=0;i<N*N;i++){for(j=i+1;j<N*N;j++){if(block[j]<block[i])less++;}}if(N%2)less+=space%2; elseless+=space%2==0; return less%2==0; } bool Node::CanRestore() const{return canberestore; }bool Node::Complete() const{int i;for(i=0;i<N*N;i++) {if(block[i]!=i+1)return false; }return true;}void Node::CalcCost() {cost=0;for(int i=0;i<N*N;i++) {if(block[i]!=i+1)cost++;}cost+=step;}void Node::Output() const {cout<<path<<endl; }bool operator <(const Node & a,const Node & b) {return a.cost<b.cost; }bool operator >(const Node & a,const Node & b) {return a.cost>b.cost; }bool Node::Move(int direction){switch(direction) {case 0: //space upif(space<4)return false;else{swap(block[space],block[space-N]);space-=N;path+='u';step++;return true;}break;case 1: //space rightif(space%N==N-1)return false;else{swap(block[space],block[space+1]); space+=1;path+='r';step++;return true;}break;case 2: //space downif(space>=N*(N-1))return false;else{swap(block[space],block[space+N]); space+=N;path+='d';step++;return true;}break;case 3: //space leftif(space%N==0)return false;else{swap(block[space],block[space-1]); space-=1;path+='l';step++;return true;}break;}return false;}string Node::State() const{string res="";int i;for(i=0;i<N*N;i++)res+=(char)('a'+block[i]);return res;}bool AStar(const Node & n){priority_queue<Node,vector<Node>,greater<Node> > pq; Node top,tmp;tmp=n;tmp.CalcCost();pq.push(tmp);set<string> ss;ss.insert(tmp.State()); while(! pq.empty()) {top=pq.top();pq.pop();if(plete()){top.Output();return true;}int i;for(i=0;i<4;i++){tmp=top;if(! tmp.Move(i))continue;tmp.CalcCost();if(ss.count(tmp.State())>0)continue;pq.push(tmp);ss.insert(tmp.State());}}return false;}int main(){int a[N*N];int i;printf("Input the initial state: use '%d' to instead of the empty block.\n",N*N); for(i=0;i<N*N;i++)scanf("%d",&a[i]); time_t t0=clock(); try{Node n(a);if(! n.CanRestore()){int error=1;throw error;}if(! AStar(n)){int fail=2;throw fail;}}catch(int e){switch(e){case 1:cerr<<"Don't cheat me please!"<<endl; break;case 2:cerr<<"Sorry, I can not restore it!"<<endl; break;default:cerr<<"Something wrong,no reason!"<<endl; break;}}printf("time cost: %d ms.\n",clock()-t0); return 0;}/*一些数据:N==3:Input the initial state: use '9' to instead of the empty block. 2 3 4 1 5 9 7 6 8ullddrurdllurrdlurdtime cost: 125 ms.Press any key to continue-------------------------------------------------------------- Input the initial state: use '9' to instead of the empty block. 6 4 7 8 5 9 3 2 1lldruurddluulddrurulldrrullddrrtime cost: 8406 ms.Press any key to continue-------------------------------------------------------------- Input the initial state: use '9' to instead of the empty block. 6 4 8 5 7 9 2 1 3ullddruulddrurdluurdluldrrdtime cost: 3328 ms.Press any key to continue-------------------------------------------------------------- Input the initial state: use '9' to instead of the empty block. 4 6 8 7 5 9 2 1 3lldruulddruuldrruldrdluurddtime cost: 2968 ms.Press any key to continue============================================================== N==4: Input the initial state: use '16' to instead of the empty block. 1 6 2 4 5 16 3 8 9 10 7 11 13 14 15 12urddrdtime cost: 16 ms.Press any key to continue-------------------------------------------------------------- Input the initial state: use '16' to instead of the empty block. 1 2 3 4 5 6 16 8 9 10 7 11 13 14 15 12drdtime cost: 0 ms.Press any key to continue*/。
人工智能实验六 A算法8数码问题
我们没有这样区分，而是将所有结点放在一个队列中，并用头指针指示 队列头结点，开始时它就是初始结点。每次都取出队列头的结点进行扩 展，当一个结点不能再扩展时，就将队列头指针加1，让它只向下一个 结点，实际上就是把不能扩展的结点放到了关闭列表中。这样在判断一 个新扩展出的结点是否与已扩展的结点重复、与那一种结点重复时，就 很方便，因为重复结点编号小于队列头指针则它在关闭列表中，重复结 点编号在队列头和尾指针之间则与可扩展结点重复，否则就不重复。 4.八数码问题的A*算法的估价函数 八数码问题的估价函数f(n)由两部分构成， g(n) 是从初始结点到结点n的 实际代价，在此它就是结点深度，也就是从初始结点到该结点的状态变 化次数，这是已知的。而 h(n) 是从结点n到目标结点最佳路径的估计代 价，这是需要定义的。通常取h(n)为当前结点各个位置上的数字（不包 括0）到目标结点同一数字所在位置的距离之和。举例来说，若当前结 点第一个位置（左上角）是3，而目标结点的数字3在最后一个位置（右 下角），那么3的距离就是4（从左上角要移动四步才到达右下角）。其 他各个数字的距离按照同样方法计算，全部数字距离之和就是h(n)。 为了计算结点的估价函数，须先计算函数h(n)，如果直接根据状态中数 字的排列进行计算比较困难。在此定义另外两个数组u(9)和v(9)，用它 们存储状态中各个数字的位置，因为每一个状态的八个数码存放在数组 p(9)中，u(9)中则按序存放0~8这些数字的位置——它们在p(9)中对应的 下标。例如，如果p(9)中的数字排列是3 5 8 0 2 1 7 6 4，则u(9)中则是3 5
If Equal(Temp, EndNode) Then DispPath head DispNode Nodes(head) Exit Sub End If If SpacMove(Temp, i) Then st = head Calcuf Temp k = Rept(Temp) If k > tail Then Sortf tail = tail + 1
人工智能实验
《人工智能导论》实验河南理工大学《人工智能》实验指导实验内容实验一状态空间搜索实验实验二 A*算法实验实验三子句消解实验实验四化为子句集的九步法实验实验五梵塔问题实验实验六 BP网络实验温馨提示：上述实验可以采用任何自己熟悉的语言来实现《人工智能导论》实验河南理工大学实验一状态空间搜索实验——八数码问题（必修，2学时）一、实验目的及内容实验目的：理解和掌握状态空间搜索的策略实验内容要求：在一个3X3的九宫中有1—8，这八个数及一个空格，随机的摆放在其中的格子里，现要求实现这个问题:将该九宫格调整为某种有序的形式，调整的原则为每次只能将空格（上、下、左、右）相邻的一个数字平移到空格中，试编程实现这一问题的求解二、实验原理及基本技术路线图（方框原理图或程序流程图）实验原理：算法分析：实验流程图：三、所用仪器、材料（设备名称、型号、规格等或使用软件）硬件:软件:四、实验方法、步骤（或：程序代码或操作过程）1.实验步骤2.实验源程序五、实验过程原始记录( 测试数据、图表、计算等)六、实验结果、分析和结论1《人工智能导论》实验河南理工大学实验二 A*算法实验（2学时）一、实验目的：熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解N数码难题，理解求解流程和搜索顺序。
二、实验原理：A*算法是一种有序搜索算法，其特点在于对估价函数的定义上。
对于一般的有序搜索，总是选择f值最小的节点作为扩展节点。
因此，f是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点n的估价函数值为两个分量：从起始节点到节点n的代价以及从节点n到达目标节点的代价。
三、实验条件：1 N数码难题演示程序。
2 IE6.0以上，可以上Internet。
三、实验内容：1 分别以8数码和15数码为例实际求解A*算法。
2 画出A*算法求解框图。
3 分析估价函数对搜索算法的影响。
4 分析A*算法的特点。
四、实验步骤：1 开始演示。
用A算法解决八数码问题
用A*算法解决八数码问题一、 题目：八数码问题也称为九宫问题。
在3×3的棋盘，有八个棋子，每个棋子上标有1至8的某一数字，分歧棋子上标的数字不相同。
棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。
要解决的问题是：任意给出一个初始状态和一个目标状态，找出一种从初始转酿成目标状态的移动棋子步数最少的移动步调。
二、 问题的搜索形式描述状态：状态描述了8个棋子和空位在棋盘的9个方格上的分布。
初始状态：任何状态都可以被指定为初始状态。
操纵符：用来发生4个行动（上下左右移动）。
目标测试：用来检测状态是否能匹配上图的目标规划。
路径费用函数：每一步的费用为1，因此整个路径的费用是路径中的步数。
现在任意给定一个初始状态，要求找到一种搜索战略，用尽可能少的步数得到上图的目标状态算法介绍三、解决方案介绍1.A*算法的一般介绍A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。
对于几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价值，即 ()()()()()()**f g n sqrt dx nx dx nx dy ny dy ny =+--+--；这样估价函数f 在g 值一定的情况下，会或多或少的受估价值h 的制约，节点距目标点近，h 值小，f 值相对就小，能包管最短路的搜索向终点的方向进行。
明显优于盲目搜索战略。
A star 算法在静态路网中的应用2.算法伪代码创建两个表，OPEN 表保管所有已生成而未考察的节点，CLOSED 表中记录已访问过的节点。
算起点的估价值，将起点放入OPEN 表。
while(OPEN!=NULL){从OPEN表中取估价值f最小的节点n;if(n节点==目标节点){break;}for(当前节点n 的每个子节点X){算X的估价值;if(X in OPEN){if( X的估价值小于OPEN表的估价值){把n设置为X的父亲;更新OPEN表中的估价值; //取最小路径的估价值}}if(X inCLOSE){if( X的估价值小于CLOSE表的估价值){把n设置为X的父亲;更新CLOSE表中的估价值;把X节点放入OPEN //取最小路径的估价值}}if(X not inboth){把n设置为X的父亲;求X的估价值;并将X拔出OPEN表中; //还没有排序}}//end for将n节点拔出CLOSE表中;依照估价值将OPEN表中的节点排序; //实际上是比较OPEN表内节点f的大小，从最小路径的节点向下进行。
人工智能九宫格重移——搜索的实验报告
人工智能九宫格重移——搜索1.问题描述：八数码问题也称为九宫问题。
在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。
棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。
要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
所谓问题的一个状态就是棋子在棋盘上的一种摆法。
棋子移动后，状态就会发生改变。
解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
2.九宫重移有无答案检查（逆序数）我们把每个9宫格横向展开，如第一个123456789，我们把左边数大于右边数的组数称为这个九宫格的逆序数，显然123456789的逆序数为0；考虑横向平移，那么逆序数的增量为2或0或-2；纵向平移，逆序数的增量为4或0或-4；但147258369的逆序数为奇数。
所以147258369是无解的情况。
由此也可以类推当将9宫格展开后，如果数据序列的逆序数为奇数，则此数据序列对应的九宫格是无解的。
3.BFS算法队列： Queue open = new Queue();存放待扩展的节点List： List<Bfstr> closed = new List<Bfstr>();存放已被扩展过的节点ArrayList map = new ArrayList();//存放答案HashTale： Hashtable table = new Hashtable();构造哈希表以方便查找3.1．BFS算法介绍广度优先搜索算法BFS基本思想：从图中某顶点v出发，逐层对节点进行拓展，并考察是否为目标节点，在第n层节点没有全部扩展并考察前，不对第n+1层节点进行扩展。
对九宫重排问题，即构造广度优先搜索树，从初始状态，利用广度优先搜索算法逐步找到目标状态的节点。
3.2．状态空间表示状态空间用一维数组表示，每个节点存放在Bfstr结构体中的字符now中，从第一行开始从左往右给九宫格标号0……8，字符串now元素下标代表格子位置，而now数组中对应数组的值代表九宫格中存放的数码，用数值9代表空格。
人工智能A算法九宫格
QOPEF PQFO PQFOද头
4
DMPTF DMPTFද头 OPX લ节 -OPEF 3OPEF 6OPEF %OPEF ԼҰࠨɼӈɼ্ɼԼ节 GOPEF 终节 JOJUJBM " TUBSU
JOTFSU -OPEF PQFO
^ JG :
OPXGBUIFS/6--]]OPXGBUIFSZ:
\
5
a算法代码的核心部分???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????层?????????????????????????????????????????????值?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????头?4???????????????????????????????????????????头????????????????????????????????????????节????????????????????????????????????????????????????节???????????????????????????????????????终节????????????????????????????????????????????????????????????????????????????????????量节点的“希望”的量度 f(n)，即用来衡量到达目标节点的路径的可
人工智能实验报告
实验一：知识表示方法一、实验目的状态空间表示法是人工智能领域最基本的知识表示方法之一，也是进一步学习状态空间搜索策略的基础，本实验通过牧师与野人渡河的问题，强化学生对知识表示的了解和应用，为人工智能后续环节的课程奠定基础。
二、问题描述有n个牧师和n个野人准备渡河，但只有一条能容纳c个人的小船，为了防止野人侵犯牧师，要求无论在何处，牧师的人数不得少于野人的人数(除非牧师人数为0)，且假定野人与牧师都会划船，试设计一个算法，确定他们能否渡过河去，若能，则给出小船来回次数最少的最佳方案。
三、基本要求输入：牧师人数(即野人人数)：n；小船一次最多载人量：c。
输出：若问题无解，则显示Failed，否则，显示Successed输出一组最佳方案。
用三元组(X1, X2, X3)表示渡河过程中的状态。
并用箭头连接相邻状态以表示迁移过程：初始状态->中间状态->目标状态。
例：当输入n=2，c=2时，输出：221->110->211->010->021->000其中：X1表示起始岸上的牧师人数；X2表示起始岸上的野人人数；X3表示小船现在位置(1表示起始岸，0表示目的岸)。
要求：写出算法的设计思想和源程序，并以图形用户界面实现人机交互，进行输入和输出结果，如：Please input n: 2 Please input c: 2Successed or Failed?: SuccessedOptimal Procedure: 221->110->211->010->021->000四、实验组织运行要求本实验采用集中授课形式，每个同学独立完成上述实验要求。
五、实验条件每人一台计算机独立完成实验。
六、实验代码Main.cpp#include<iostream>#include"RiverCrossing.h"using namespace std;//主函数void main(){RiverCrossing::ShowInfo();int n, c;cout<<"Please input n: ";cin>>n;cout<<"Please input c: ";cin>>c;RiverCrossing riverCrossing(n, c);riverCrossing.solve();system("pause");}RiverCrossing.h #pragma once#include<list>//船class Boat{public:static int c;int pastor;//牧师int savage;//野人Boat(int pastor, int savage);};//河岸状态class State{public:static int n;int iPastor;//牧师数量int iSavage;//野人数量int iBoatAtSide;//船所在河岸State *pPrevious;//前一个状态State(int pastor, int savage, int boatAtSide);int getTotalCount();//获得此岸总人数bool check();//检查人数是否符合实际bool isSafe();//检查是否安全State operator + (Boat &boat);State operator - (Boat &boat);bool operator == (State &state);};//过河问题class RiverCrossing{private:std::list<State*> openList, closeList;State endState;bool move(State *nowState, Boat *boat);//进行一次决策State* findInList(std::list<State*> &listToCheck, State &state);//检查某状态节点是否在列表中void print(State *endState);//打印结果public:static void ShowInfo();RiverCrossing(int n, int c);bool solve();//求解问题};RiverCrossing.cpp#include"RiverCrossing.h"#include<iostream>#include<stack>#include<algorithm>using namespace std;//类静态变量定义int State::n = 0;int Boat::c = 0;/*=========================Methods for class "Boat"=========================*/ Boat::Boat(int pastor, int savage){this->pastor = pastor;this->savage = savage;}/*=========================Methods for class "State"=========================*/ //构造函数State::State(int pastor, int savage, int boatAtSide){this->iPastor = pastor;this->iSavage = savage;this->iBoatAtSide = boatAtSide;this->pPrevious = NULL;}//获取此岸总人数int State::getTotalCount(){return iPastor + iSavage;}//检查人数是否在0到n之间bool State::check(){return (iPastor >=0 && iPastor <= n && iSavage >= 0 && iSavage <=n);}//按照规则检查牧师得否安全bool State::isSafe(){//此岸的安全：x1 == 0 || x1 >= x2//彼岸的安全：(n-x1) == 0 || (n-x1) >= (n-x2)//将上述条件联立后得到如下条件return (iPastor == 0 || iPastor == n || iPastor == iSavage);}//重载+符号，表示船开到此岸State State::operator+(Boat &boat){State ret(iPastor + boat.pastor, iSavage + boat.savage, iBoatAtSide + 1);ret.pPrevious = this;return ret;}//重载-符号，表示船从此岸开走State State::operator-(Boat &boat){State ret(iPastor - boat.pastor, iSavage - boat.savage, iBoatAtSide - 1);ret.pPrevious = this;return ret;}//重载==符号，比较两个节点是否是相同的状态bool State::operator==(State &state){return (this->iPastor == state.iPastor && this->iSavage == state.iSavage && this->iBoatAtSide == state.iBoatAtSide);}/*=======================Methods for class "RiverCrossing"=======================*/ //显示信息void RiverCrossing::ShowInfo(){cout<<"************************************************"<<endl;cout<<" 牧师与野人过河问题求解 "<<endl;cout<<" by 1040501211 陈嘉生 "<<endl;cout<<"************************************************"<<endl;}//构造函数RiverCrossing::RiverCrossing(int n, int c):endState(0, 0, 0){State::n = n;Boat::c = c;}//解决问题bool RiverCrossing::solve(){openList.push_back(new State(State::n, State::n, 1));while(!openList.empty()) {//获取一个状态为当前状态State *nowState = openList.front();openList.pop_front();closeList.push_back(nowState);//从当前状态开始决策if (nowState->iBoatAtSide == 1) {//船在此岸//过河的人越多越好，且野人优先int count = nowState->getTotalCount();count = (Boat::c >= count ? count : Boat::c);for (int capticy = count; capticy >= 1; --capticy) {for (int i = 0; i <= capticy; ++i) {Boat boat(i, capticy - i);if (move(nowState, &boat))return true;}}} else if (nowState->iBoatAtSide == 0) {//船在彼岸//把船开回来的人要最少，且牧师优先for (int capticy = 1; capticy <= Boat::c; ++capticy) { for (int i = 0; i <= capticy; ++i) {Boat boat(capticy - i, i);if (move(nowState, &boat))return true;}}}}print(NULL);return false;}//实施一步决策，将得到的新状态添加到列表，返回是否达到目标状态bool RiverCrossing::move(State *nowState, Boat *boat){//获得下一个状态State *destState;if (nowState->iBoatAtSide == 1) {destState = new State(*nowState - *boat);//船离开此岸} else if (nowState->iBoatAtSide == 0) {destState = new State(*nowState + *boat);//船开到此岸}if (destState->check()) {//检查人数if (*destState == endState) {//是否达到目标状态closeList.push_back(destState);print(destState);return true;//找到结果} else if (destState->isSafe()) {//检查是否安全if (!findInList(openList, *destState) && !findInList(closeList,*destState)) {//检查是否在表中//添加没出现过的状态节点到open表openList.push_back(destState);return false;}}}delete destState;return false;}//检查给定状态是否存在于列表中State* RiverCrossing::findInList(list<State*> &listToCheck, State &state){for (list<State*>::iterator ite = listToCheck.begin(); ite != listToCheck.end(); ++ite) {if (**ite == state)return *ite;}return NULL;}//根据达到的目标状态，回溯打印出求解过程void RiverCrossing::print(State *endState){cout<<"================================================"<<endl;if (!endState) {cout<<"Search failed!"<<endl;} else {cout<<"Search successed!"<<endl;cout<<"Optimal Procedure: "<<endl;State *pState = endState;stack<State*> st;//用栈将链表逆序，以便输出while (pState) {st.push(pState);pState = pState->pPrevious;}int count = 0;while (!st.empty()) {pState = st.top();st.pop();cout<<pState->iPastor<<","<<pState->iSavage<<","<<pState->iBoatAtSide;if (st.size() > 0)cout<<" -> ";if (++count % 5 == 0)//每五个步骤换行cout<<endl;}cout<<endl;cout<<"Total move: "<<count - 1<<endl;}cout<<"================================================"<<endl;}七、实验结果实验二：九宫重排一、实验目的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数码问题时取得良好的运算的结果，它可以很好的
评估问题的最优解，因此使得搜索树更加有效，从而减少计算机运算时间，提升解答效率。
人工智能课内实验报告2
人工智能课内实验报告（二） ----重排九宫（A*算法）一、实验目的1. 熟悉启发式搜索的思想，加深对各种图搜索策略概念的理解；2. 运用搜索算法重排九宫使之从初始状态到底目标状态，并求解最短路径。
二、实验内容在三种不同的搜索算法中任选一种实现重排九宫。
这三种方法分别是：A*算法、有界深度优先搜索和广度优先搜索。
具体描述：在一个3×3的方格棋盘上放置8个标有1、2、3、4、5、6、7、8数字的将牌，留下一个空格（用0表示）。
规定：与空格相邻的将牌可以移入空格。
要求：寻找一条从初始状态到目标状态的将牌移动路线。
三、实验原理启发式搜索是在搜索中加入了与问题有关的启发性信息，用以指导搜索朝着最有希望的方向前进，加速问题的求解过程并找到最优解。
A*算法是一种启发式搜索。
广度优先搜索按照“先扩展出的节点先被考察”的原则进行搜索。
深度优先搜索按照“后扩展出的节点先被考察”的原则进行搜索。
有界深度优先搜索的原则与深度优先搜索相同，但是它规定了深度限界，使搜索不得无限制地向纵深方向发展。
（一）搜索的一般描述：1. 把初始节点S0放入OPEN表，并建立目前只包含S0的图，记为G；2. 检查OPEN表是否为空，若为空则问题无解，退出；3. 把OPEN表的第一个节点取出放入CLOSE表，并计该节点为n；4. 考察节点n是否为目标节点。
若是，则求得了问题的解，退出；5. 扩展节点n，生成一组子节点。
把其中不是节点n先辈的那些子节点记做集合M，并把这些子节点作为节点n的子节点加入G中；6. 针对M中子节点的不同情况，分别进行如下处理：（1）对于那些未曾在G中出现过的M成员设置一个指向父节点（即节点n）的指针，并把它们放入OPEN表；（不在OPEN表）（2）对于那些先前已经在G中出现过的M成员，确定是否需要修改它指向父节点的指针；（在OPEN表中）（3）对于那些先前已在G中出现并且已经扩展了的M成员，确定是否需要修改其后继节点指向父节点的指针；（在CLOSE表中）7. 按某种搜索策略对OPEN表中的节点进行排序；8. 转第2步。
人工智能论文：九宫重排问题
滨江学院课程论文课程名称:人工智能院系滨江学院专业自动化学号姓名指导老师二Ｏ一六年六月二十日引言 (3)一、问题描述 (3)1.1 待解决问题的解释 (3)1.2 问题的搜索形式描述（4要素） (3)1.3 解决原理 (4)二、算法介绍 (4)2.1 搜索算法一般介绍 (4)2.2 算法伪代码 (5)三、数据介绍 (7)3.1 数据结构 (7)3.2 实验结果 (8)3.3 系统中间及最终输出结果（要求有屏幕显示） (9)参考文献 (11)人工智能是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。
人工智能的研究方向、研究领域、应用领域值得我们关注和探讨。
本文以状态空间搜索的观点讨论了八数码问题，给出了八数码问题的Java 算法与实现的思想，分析了A*算法的可采纳性等及系统的特点。
关键词:九宫重排，状态空间，启发式搜索，A*算法引言九宫重排问题是人工智能当中有名的难题之一。
问题是在3×3方格盘上，放有八个数码，剩下一个位置为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始状态转化为目标状态。
状态转换的规则：空格四周的数移向空格，我们可以看作是空格移动，它最多可以有４个方向的移动，即上、下、左、右。
九宫重排问题的求解方法，就是从给定的初始状态出发，不断地空格上下左右的数码移至空格，将一个状态转化成其它状态，直到产生目标状态。
一、问题描述1.1 待解决问题的解释八数码游戏（八数码问题）描述为：在3×3组成的九宫格棋盘上，摆有八个将牌，每一个将牌都刻有1-8八个数码中的某一个数码。
棋盘中留有一个空格，允许其周围的某一个将牌向空格移动，这样通过移动将牌就可以不断改变将牌的布局。
这种游戏求解的问题是：给定一种初始的将牌布局或结构（称初始状态）和一个目标的布局（称目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。
人工智能A算法九宫格报告
实验一 A*算法实现八数码搜索问题题目：编程实现8数码问题初始状态：3 8 21 57 6 4目标状态：1 2 38 47 6 5要求：1、报告：给出状态表示，编码规则，搜索算法A*，简单程序说明，最优路径。
2、调通的程序（语言不限）一、状态表示用一个3×3的数组来表示状态，数组中的各个元素对应状态位置的数字。
其中空格用0表示。
二、编码规则在程序实现过程中，只有移动0的位置，即可生成新的节点。
规则库设数组中0的位置为a[i][j]，其中0≤i≤2，0≤j≤2。
R1：if(i≥1) then 上移R1：if(i≤1) then 下移R1：if(j≥1) then 左移R1：if(j≤1) then 右移三、搜索算法A*用于度量节点的“希望”的量度f(n)，即用来衡量到达目标节点的路径的可能性大小。
A算法：基本思想：定义一个评价函数，对当前的搜索状态进行评估，找出一个最有希望的节点进行扩展：f(n) = g(n) + h(n)，n为被评价节点g*(n)：从s到n的最优路径的实际代价h*(n)：从n到g的最优路径的实际代价f*(n)=g*(n)+h*(n)：从s经过n到g的最优路径的实际代价g(n)、h(n)、f(n)分别是g*(n)、h*(n)、f*(n)的估计值g (n)通常为从S到到n这段路径的实际代价，则有g (n) ≥ g*(n)h (n):是从节点n到目标节点Sg的最优路径的估计代价. 它的选择依赖于有关问题领域的启发信息，叫做启发函数A算法：在图搜索的一般算法中，在搜索的每一步都利用估价函数f(n)=g(n)+h(n)对Open表中的节点进行排序表中的节点进行排序, 找出一个最有希望的节点作为下一次扩展的节点。
在A算法中，如果满足条件：h(n)≤h*(n)，则A算法称为A*算法。
在本算法中，为实现八数码的搜索问题，定义估价函数为：f(n)=g(n)+h(n)，其中g（n）表示节点n在搜索树中的深度；h（n）表示节点n的各个数码到目标位置的曼哈顿距离和。
A算法求解九宫问题
A*算法求解九宫问题1题目分析A*算法是一种静态路网中求解最短路最有效的方法。
九宫问题是这样的：将数字l～8按照任意次序排在3x3的方格阵列中，留下一个空格。
与空格相邻的数字，允许从上、下、左，右方向移动到空格中。
游戏的最终日标是通过合法移动，将数字从给定的初始布局转变到按顺序排列布局2算法构造输入初始状态和目标状态的数据；输出从初始状态到目标状态的一系列过程移动每一步时的序号，最后一步的序号即为移动总步数；每一步移动后以３*３表格形式显示状态。
要求能使移动步数尽可能少。
3算法实现#include<iostream>using namespace std;pnode move(pnode p,int dir){pnode Unode=(pnode)malloc(sizeof(node));for(int i=0;i<=2;i++){ for(int j=0;j<=2;j++){Unode->a[i][j]=p->a[i][j];}}switch(dir){case 1: //up{Unode->x=p->x-1;Unode->y=p->y;Unode->a[Unode->x][Unode->y]=0;Unode->a[Unode->x+1][Unode->y]=p->a[Unode->x][Unode->y];break;}case 2:………………//down}Unode->father=p;Unode->g=p->g+1;//深度增加一层Unode->h=hvalue(Unode->a,final); //更新h函数值Unode->f=Unode->h+Unode->g;return Unode;}int main(int argc, char *argv[]){pnode A0=(pnode)malloc(sizeof(node));pnode open, //open表头close, //close表头now, //当前节点Lnode,Rnode,Unode,Dnode, //下一个左，右，上，下节点fnode; //终节点initial(A0,start);open=A0;close=NULL;while(1){if(open==NULL) //Open表为空，未找到解，结束搜索程序{fnode=NULL;cout<<"未能找到解" ;return 0;}if(open->h==0) //open表中第一个节点是解，结束搜索{fnode=open; //把final node从open表中拿出，放到close表中 open=open->next;fnode->next=NULL;fnode->clnext=close;close=fnode;break;}now=open;int X,Y;X=now->x;Y=now->y;if((X>0)&&(now->father==NULL||now->father->x!=X-1)){Unode=move(now,1); //空格上移，得到新节点insert(Unode,open); //把新节点插入open表中}if((X<2)&&(now->father==NULL||now->father->x!=X+1)){ //空格下移Dnode=move(now,2);insert(Dnode,open);}if((Y>0)&&(now->father==NULL||now->father->y!=Y-1)){Lnode=move(now,3);insert(Lnode,open);}if((Y<2)&&(now->father==NULL||now->father->y!=Y+1)){Rnode=move(now,4);insert(Rnode,open);}now->clnext=close; //把当前节点放入到close表close=now;open=open->next; //把open表头指向下一个表内节点 }while(fnode->father!=NULL) //回溯到始节点，建立解的链表{fnode->father->next=fnode;fnode=fnode->father;}while(fnode!=NULL) //从头节点打印到终节点{disp(fnode);fnode=fnode->next;}freeclose(close); //释放close表中节点的内存freeopen(open); //释放open表中节点的内存return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
\ QOPEF" QOPEF
NBMMPD TJ[FPG OPEF
\ DBTF VQ \ 6OPEFYQY 6OPEFZQZ 6OPEFB<6OPEFY><6OPEFZ> 6OPEFB<6OPEFY ><6OPEFZ>QB<6OPEFY><6OPEFZ> CSFBL ^ DBTF||||||EPXO ^ 6OPEFGBUIFSQ 6OPEFHQH ਂ⃧ՃҰ层 6OPEFIIWBMVF 6OPEFB GJOBM
OPXGBUIFS/6--]]OPXGBUIFSY9
\ 6OPEFNPWF OPX
্ۭ֨Ҡɼಘ౸৽节 JOTFSU 6OPEF PQFO
二、 编码规则 在程序实现过程中，只有移动 0 的位置，即可生成新的节点。 规则库 设数组中 0 的位置为 a[i][j]，其中 0≤i≤2，0≤j≤2。 R1：if(i≥1) then 上移 R1：if(i≤1) then 下移 R1：if(j≥1) then 左移 R1：if(j≤1) then 右移
JOTFSU -OPEF PQFO
^ JG :
OPXGBUIFS/6--]]OPXGBUIFSZ:
\
5
h（n）表示节点 n 的各个数码到目标位置的曼哈顿距离和。
四、 程序说明 1、算法实现的步骤： （1）把初始节点 S0 放入 Open 表中，置 S0 的代价 g(S0)=0； （2）如果 Open 表为空，则问题无解，失败退出； （3）把 Open 表的第一个节点取出放入 Closed 表，并记该节点为 n （4）考察节点 n 是否为目标节点。若是，则找到了问题的解，成功退出； （5）若节点 n 不可扩展，则转第（2）步； （6）扩展节点 n，生成其子节点 ni, （其中 i=1,2,3,……），将这些子节点放入 Open 表中，并为每一个子节点设置指向父节点的指针；按公式 g（ni）=g(n)＋ c(n，ni)（i=1，2，…）计算 Open 表中的各子节点的代价，并根据各节点的代价 对 Open 表中的全部节点按照从小到大顺序重新进行排序；然后转第（2）步。 2、思路 通过代价函数对 Open 表中的节点进行排序，代价小的先扩展。
2
五、 搜索算法得出的最优路径 如下图所示，搜索算法从初始节点到目标节点经历了 18 个状态。
图 1.Visual C++ 环境下运行结果
3
六、 结论 通过这次的实验，深入了解了启发式搜索算法的内涵，尤其是 A*算法的优
越性。然而在实际工程中，选择合适、优异的估价函数存在一定困难，特别要注
৽节ᎎೖPQFOදத ^ JG 9
OPXGBUIFS/6--]]OPXGBUIFSY9
\ ۭ֨ԼҠ %OPEFNPWF OPX
1
三、 搜索算法 A* 用于度量节点的“希望”的量度 f(n)，即用来衡量到达目标节点的路径的可
能性大小。 A 算法： 基本思想：定义一个评价函数，对当前的搜索状态进行评估，找出一个最
有希望的节点进行扩展：f(n) = g(n) + h(n)，n 为被评价节点 g*(n)：从 s 到 n 的最优路径的实际代价 h*(n)：从 n 到 g 的最优路径的实际代价 f*(n)=g*(n)+h*(n)：从 s 经过 n 到 g 的最优路径的实际代价 g(n)、h(n)、f(n)分别是 g*(n)、h*(n)、f*(n)的估计值 g (n)通常为从 S 到到 n 这段路径的实际代价，则有 g (n) ≥ g*(n) h (n):是从节点 n 到目标节点 Sg 的最优路径的估计代价. 它的选择依赖于有
3OPEFNPWF OPX
JOTFSU 3OPEF PQFO
^ OPXDMOFYUDMPTF લ节์ೖ౸DMPTFද DMPTFOPX PQFOPQFOOFYU PQFOද头ࢦԼҰද节 ^ XIJMF GOPEFGBUIFS/6--
PQFO" DMPTF/6-- XIJMF
\ JG PQFO/6--
0QFOද为ۭɼະፙ౸ղɼ结ଋ፺ࡧఔং \ GOPEF/6-- DPVUະೳፙ౸ղ SFUVSO ^ JG PQFOI
PQFOදதୈҰ节ੋղɼ结ଋ፺ࡧ \ GOPEFPQFO GJOBMOPEFဓPQFOදத፤ग़ɼ์౸DMPTFදத PQFOPQFOOFYU GOPEFOFYU/6-- GOPEFDMOFYUDMPTF DMPTFGOPEF CSFBL ^ OPXPQFO JOU9 : 9OPXY:OPXZ JG 9
意其信息量的强度不能超过其上限值，否则 A*算法会变成 A 算法；而 A 算法是 非充分的，即可能不在其最优路径上，从而导致不能找到目标节点。
同时，在实验过程中，也熟悉了 C++编程和 VC 的开发环境；但编程能力 还是极其有限，急需提升。
附录：
A*算法代码的核心部分
QOPEFNPWF QOPEFQ JOUEJS
人工智能原理与方法
A*算法实现八数码搜索问题
模式识别与智能系统 SY1003113 游遵文
题目：编程实现 8 数码问题 初始状态：
3
8
2
1
5
7
6
4
目标状态：
1
2
3
8
4
7
6
5
要求：1、报告：给出状态表示，编码规则，搜索算法 A*，简单程序说明，最优 路径。
2、调通的程序（语言不限）
一、 状态表示 用一个 3×3 的数组来表示状态，数组中的各个元素对应状态位置的数字。 其中空格用 0 表示。
\ QOPEF6OPEF QOPEF
NBMMPD TJ[FPG OPEF
GPS JOUJJJ
\ GPS JOUKKK
\ 6OPEFB<J><K>QB<J><K> ^ ^ TXJUDI EJS
QOPEF PQFO PQFOද头
4
DMPTF DMPTFද头 OPX લ节 -OPEF 3OPEF 6OPEF %OPEF ԼҰࠨɼӈɼ্ɼԼ节 GOPEF 终节 JOJUJBM " TUBSU
JOTFSU %OPEF PQFO
^ JG :
OPXGBUIFS/6--]]OPXGBUIFSZ:
\ -OPEFNPWF OPX
ճᕧ౸࢝节ɼཱݐղతFYUGOPEF GOPEFGOPEFGBUIFS ^ XIJMF GOPEF/6--
关问题领域的启发信息，叫做启发函数 A 算法：在图搜索的一般算法中，在搜索的每一步都利用估价函数
f(n)=g(n)+h(n)对 Open 表中的节点进行排序表中的节点进行排序, 找出一个最有 希望的节点作为下一次扩展的节点。
在 A 算法中，如果满足条件：h(n)≤h*(n)，则 A 算法称为 A*算法。 在本算法中，为实现八数码的搜索问题，定义估价函数为：f(n)=g(n)+h(n)， 其中 g（n）表示节点 n 在搜索树中的深度；