人工智能实验八数码问题的求解策略
八数码问题求解实验报告
八数码问题求解（一）实验软件TC2.0或VC6.0编程语言或其它编程语言（二）实验目的1.熟悉人工智能系统中的问题求解过程；2.熟悉状态空间的盲目搜索和启发式搜索算法的应用；3.熟悉对八数码问题的建模，求解及编程语言的应用。
（三）实验内容八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有一个方格是空的，要求对空格执行空格左移，空格右移，空格上移，空格下移这四个操作使得棋盘从初始状态到目标状态。
输入初始状态和目标状态，输出从初始状态到目标状态的路径。
（四）实验代码#include"stdafx.h"#include<iostream>#include<ctime>#include<vector>using namespace std;const int ROW = 3;const int COL = 3;const int MAXDISTANCE = 10000;const int MAXNUM = 10000;typedef struct_Node{int digit[ROW][COL];int dist; // distance between one state and the destination int dep; // the depth of node// So the comment function = dist + dep.int index; // point to the location of parent} Node;Node src, dest;vector<Node> node_v; // store the nodesbool isEmptyOfOPEN() {for (int i = 0; i < node_v.size(); i++) {if (node_v[i].dist != MAXNUM)return false;}return true;}bool isEqual(int index, int digit[][COL]) {for (int i = 0; i < ROW; i++)for (int j = 0; j < COL; j++) {if (node_v[index].digit[i][j] != digit[i][j])return false;}return true;}ostream& operator<<(ostream& os, Node& node) {for (int i = 0; i < ROW; i++) {for (int j = 0; j < COL; j++)os << node.digit[i][j] << ' ';os << endl;}return os;}void PrintSteps(int index, vector<Node>& rstep_v) { rstep_v.push_back(node_v[index]);index = node_v[index].index;while (index != 0) {rstep_v.push_back(node_v[index]);index = node_v[index].index;}for (int i = rstep_v.size() - 1; i >= 0; i--)cout << "Step " << rstep_v.size() - i<< endl << rstep_v[i] << endl;}void Swap(int& a, int& b) {int t;t = a;a = b;b = t;}void Assign(Node& node, int index) {for (int i = 0; i < ROW; i++)for (int j = 0; j < COL; j++)node.digit[i][j] = node_v[index].digit[i][j];}int GetMinNode() {int dist = MAXNUM;int loc; // the location of minimize nodefor (int i = 0; i < node_v.size(); i++) {if (node_v[i].dist == MAXNUM)continue;else if ((node_v[i].dist + node_v[i].dep) < dist) {loc = i;dist = node_v[i].dist + node_v[i].dep;}}return loc;}bool isExpandable(Node& node) {for (int i = 0; i < node_v.size(); i++) {if (isEqual(i, node.digit))return false;}return true;}//扩展int Distance(Node& node, int digit[][COL]) {int distance = 0;bool flag = false;for (int i = 0; i < ROW; i++)for (int j = 0; j < COL; j++)for (int k = 0; k < ROW; k++) {for (int l = 0; l < COL; l++) {if (node.digit[i][j] == digit[k][l]) {distance += abs(i - k) + abs(j - l);//abs()求得是正数的绝对值。
人工智能8位数码难题的问题求解
#define DOWN 1
#define LEFT 2
#define RIGHT 3
#define Bit char
typedef struct maps
{
Bit detail[9];
int myindex; //记录自己节点在hash表中的位置
Bit position; //记录空格（0）在序列中的位置
实验软硬件要求：网络计算机，c++编程环境
实验内容、方法和步骤（可附页）
我们将八数码难题分布在3×3方格棋盘上，分别放置了标有数字1,2,3,4,5,6,7,8的八张牌，初始状态S0，目标状态如图所示，可以使用的操作有:空格上移，空格左移，空格右移，空格下移。我们将是用广度优先搜索算法来解决这一问题。
int newindex = Parent.myindex ;
Bit *p = Parent.detail;
switch(direct)
{
case UP :
{
newindex -= 3*40320 ;
newindex += ( p[ i - 2 ] > p[ i - 3 ]) ? ( Factorial[ p[ i - 3 ] ] ) : ( - Factorial[ p[ i - 2 ] ] );
}p,*PMap;
Map org; //初始状态
int EndIndex; //目标,上移，下移，左移，右移
int const derection[4] ={ -3 , 3 , -1 , 1 } ;
//可移动的四个方向
int const Factorial[9] = {40320 , 5040 , 720 , 120 , 24 , 6 , 2 , 1 , 1 };
八数码实验报告
八数码实验报告八数码实验报告引言：八数码，也被称为滑块拼图，是一种经典的益智游戏。
在这个实验中，我们将探索八数码问题的解决方案，并分析其算法的效率和复杂性。
通过这个实验，我们可以深入了解搜索算法在解决问题中的应用，并且探讨不同算法之间的优劣势。
1. 问题描述：八数码问题是一个在3x3的方格上进行的拼图游戏。
方格中有8个方块，分别标有1到8的数字，还有一个空方块。
游戏的目标是通过移动方块，将它们按照从左上角到右下角的顺序排列。
2. 算法一：深度优先搜索（DFS）深度优先搜索是一种经典的搜索算法，它从初始状态开始，不断地向前搜索，直到找到目标状态或者无法继续搜索为止。
在八数码问题中，深度优先搜索会尝试所有可能的移动方式，直到找到解决方案。
然而，深度优先搜索在解决八数码问题时存在一些问题。
由于搜索的深度可能非常大，算法可能会陷入无限循环，或者需要很长时间才能找到解决方案。
因此，在实际应用中，深度优先搜索并不是最优的选择。
3. 算法二：广度优先搜索（BFS）广度优先搜索是另一种常用的搜索算法，它从初始状态开始，逐层地向前搜索，直到找到目标状态。
在八数码问题中，广度优先搜索会先尝试所有可能的一步移动，然后再尝试两步移动，依此类推，直到找到解决方案。
与深度优先搜索相比，广度优先搜索可以保证找到最短路径的解决方案。
然而，广度优先搜索的时间复杂度较高，尤其是在搜索空间较大时。
因此，在实际应用中，广度优先搜索可能不太适合解决八数码问题。
4. 算法三：A*算法A*算法是一种启发式搜索算法，它在搜索过程中利用了问题的启发信息，以提高搜索效率。
在八数码问题中，A*算法会根据每个状态与目标状态之间的差异，选择最有可能的移动方式。
A*算法通过综合考虑每个状态的实际代价和启发式估计值，来评估搜索路径的优劣。
通过选择最优的路径，A*算法可以在较短的时间内找到解决方案。
然而，A*算法的实现较为复杂，需要合适的启发函数和数据结构。
八数码难题（8puzzle）深度优先和深度优先算法
⼋数码难题（8puzzle）深度优先和深度优先算法1 搜索策略搜索策略是指在搜索过程中如何选择扩展节点的次序问题。
⼀般来说，搜索策略就是采⽤试探的⽅法。
它有两种类型：⼀类是回溯搜索，另⼀类是图搜索策略。
2 盲⽬的图搜索策略图搜索策略⼜可分为两种：⼀种称为盲⽬的图搜索策略，或称⽆信息图搜索策略；⽽另⼀种称为启发式搜索策略，⼜称为有信息的图搜索策略。
最常⽤的两种⽆信息图搜索策略是宽度优先搜索和深度优先搜索。
2.1 宽度优先搜索它是从根节点（起始节点）开始，按层进⾏搜索，也就是按层来扩展节点。
所谓按层扩展，就是前⼀层的节点扩展完毕后才进⾏下⼀层节点的扩展，直到得到⽬标节点为⽌。
这种搜索⽅式的优点是，只要存在有任何解答的话，它能保证最终找到由起始节点到⽬标节点的最短路径的解，但它的缺点是往往搜索过程很长。
2.2 深度优先搜索它是从根节点开始，⾸先扩展最新产⽣的节点，即沿着搜索树的深度发展下去，⼀直到没有后继结点处时再返回，换⼀条路径⾛下去。
就是在搜索树的每⼀层始终先只扩展⼀个⼦节点，不断地向纵深前进直到不能再前进（到达叶⼦节点或受到深度限制）时，才从当前节点返回到上⼀级节点，沿另⼀⽅向⼜继续前进。
这种⽅法的搜索树是从树根开始⼀枝⼀枝逐渐形成的。
由于⼀个有解的问题树可能含有⽆穷分枝，深度优先搜索如果误⼊⽆穷分枝（即深度⽆限），则不可能找到⽬标节点。
为了避免这种情况的出现，在实施这⼀⽅法时，定出⼀个深度界限，在搜索达到这⼀深度界限⽽且尚未找到⽬标时，即返回重找，所以，深度优先搜索策略是不完备的。
另外，应⽤此策略得到的解不⼀定是最佳解（最短路径）。
3 “⼋”数码难题的宽度优先搜索与深度优先搜索3.1“⼋”数码难题的宽度优先搜索步骤如下：1、判断初始节点是否为⽬标节点，若初始节点是⽬标节点则搜索过程结束；若不是则转到第2步；2、由初始节点向第1层扩展，得到3个节点：2、3、4；得到⼀个节点即判断该节点是否为⽬标节点，若是则搜索过程结束；若2、3、4节点均不是⽬标节点则转到第3步；3、从第1层的第1个节点向第2层扩展，得到节点5；从第1层的第2个节点向第2层扩展，得到3个节点：6、7、8；从第1层的第3个节点向第2层扩展得到节点9；得到⼀个节点即判断该节点是否为⽬标节点，若是则搜索过程结束；若6、7、8、9节点均不是⽬标节点则转到第4步；4、按照上述⽅法对下⼀层的节点进⾏扩展，搜索⽬标节点；直⾄搜索到⽬标节点为⽌。
C语言解八数码问题之人工智能实验报告
C语言解八数码问题之人工智能实验报告《人工智能》上机实验基于人工智能的状态空间搜索策略研究——八数码问题求解(一)实验软件TC2.0 或 VC6.0 编程语言或其它编程语言(二)实验目的1. 熟悉人工智能系统中的问题求解过程;2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用;3. 熟悉对八数码问题的建模、求解及编程语言的应用。
(三)需要的预备知识1. 熟悉TC2.0 或 VC6.0 编程语言或者其它编程语言;2. 熟悉状态空间的宽度优先搜索、深度优先搜索和启发式搜索算法;3. 熟悉计算机语言对常用数据结构如链表、队列等的描述应用;4. 熟悉计算机常用人机接口设计。
(四)实验数据及步骤1. 实验内容八数码问题:在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
2 5 4 1 2 33 7 8 41 8 6 7 6 5(a) 初始状态 (b) 目标状态图1 八数码问题示意图请任选一种盲目搜索算法(深度优先搜索或宽度优先搜索)或任选一种启发式搜索方法(A 算法或 A* 算法)编程求解八数码问题(初始状态任选)，并对实验结果进行分析，得出合理的结论。
2. 实验步骤(1)分析算法基本原理和基本流程;程序采用宽度优先搜索算法，基本流程如下:2起始把s放入open表是是否open表为失败空表,否把open表中的第一个节点n移入close表扩展节点n，把其后裔放入open表的前头是否是否有后继节点成功为目标节点,3(2)确定对问题描述的基本数据结构，如 Open 表和 Closed 表等;OPEN CLOSED SA,B,C SB,C,D,E,F S,AC,D,E,F,G S,A,B D,E,F,G,H S,A,B,C E,F,G,H,I,J S,A,B,C,D F,G,H,I,J K,L S,A,B,C,D,E G,H,I,J K,L,M,N S,A,B,C,D,E,F H,I,J K,L,M,N,O,PS,A,B,C,D,E,F,G(3)编写算符运算、目标比较等函数;(4)编写输入、输出接口;(5)全部模块联调;(6)撰写实验报告。
人工智能实验一_八数码问题
用A*算法解决八数码问题1 问题描述1.1 待解决问题的解释八数码游戏（八数码问题）描述为：在3×3组成的九宫格棋盘上，摆有八个将牌，每一个将牌都刻有1-8八个数码中的某一个数码。
棋盘中留有一个空格，允许其周围的某一个将牌向空格移动，这样通过移动将牌就可以不断改变将牌的布局。
这种游戏求解的问题是：给定一种初始的将牌布局或结构（称初始状态）和一个目标的布局（称目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。
1.2 问题的搜索形式描述（4要素）初始状态：8个数字将牌和空格在九宫格棋盘上的所有格局组成了问题的状态空间。
其中，状态空间中的任一种状态都可以作为初始状态。
后继函数：通过移动空格（上、下、左、右）和周围的任一棋子一次，到达新的合法状态。
目标测试：比较当前状态和目标状态的格局是否一致。
路径消耗：每一步的耗散值为1，因此整个路径的耗散值是从起始状态到目标状态的棋子移动的总步数。
1.3 解决方案介绍（原理）对于八数码问题的解决，首先要考虑是否有答案。
每一个状态可认为是一个1×9的矩阵，问题即通过矩阵的变换，是否可以变换为目标状态对应的矩阵？由数学知识可知，可计算这两个有序数列的逆序值，如果两者都是偶数或奇数，则可通过变换到达，否则，这两个状态不可达。
这样，就可以在具体解决问题之前判断出问题是否可解，从而可以避免不必要的搜索。
如果初始状态可以到达目标状态，那么采取什么样的方法呢？常用的状态空间搜索有深度优先和广度优先。
广度优先是从初始状态一层一层向下找，直到找到目标为止。
深度优先是按照一定的顺序前查找完一个分支，再查找另一个分支，以至找到目标为止。
广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。
这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不预测的情况下就不可取了。
他的效率实在太低，甚至不可完成。
由于八数码问题状态空间共有9!个状态，对于八数码问题如果选定了初始状态和目标状态，有9!/2个状态要搜索，考虑到时间和空间的限制，在这里采用A*算法作为搜索策略。
人工智能实验六 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
八数码 人工智能实验报告
八数码人工智能实验报告八数码人工智能实验报告引言：八数码是一种经典的数学问题，也是人工智能领域中常用的实验题目之一。
本次实验旨在通过使用搜索算法解决八数码问题，探讨人工智能在解决复杂问题上的应用。
一、问题描述：八数码问题是一种数字排列游戏，使用一个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*算法通过合理的启发函数和优先队列的维护，能够高效地找到最优解。
八数码问题人工智能实验报告
基于人工智能的状态空间搜索策略研究——八数码问题求解（一）实验软件或编程语言或其它编程语言（二）实验目的1. 熟悉人工智能系统中的问题求解过程；2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用；3. 熟悉对八数码问题的建模、求解及编程语言的应用。
（三）需要的预备知识1. 熟悉或编程语言或者其它编程语言；2. 熟悉状态空间的宽度优先搜索、深度优先搜索和启发式搜索算法；3. 熟悉计算机语言对常用数据结构如链表、队列等的描述应用；4. 熟悉计算机常用人机接口设计。
（四）实验数据及步骤1. 实验内容八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
437465图1 八数码问题示意图请任选一种盲目搜索算法（深度优先搜索或宽度优先搜索）或任选一种启发式搜索方法（A 算法或 A* 算法）编程求解八数码问题（初始状态任选），并对实验结果进行分析，得出合理的结论。
2. 实验步骤（1）分析算法基本原理和基本流程；程序采用宽度优先搜索算法，基本流程如下：（2）确定对问题描述的基本数据结构，如 Open 表和 Closed 表等；（3）编写算符运算、目标比较等函数；（4）编写输入、输出接口；（5）全部模块联调；（6）撰写实验报告。
（五）实验报告要求所撰写的实验报告必须包含以下内容：1. 算法基本原理和流程框图；2. 基本数据结构分析和实现；3. 编写程序的各个子模块，按模块编写文档，含每个模块的建立时间、功能、输入输出参数意义和与其它模块联系等；4. 程序运行结果，含使用的搜索算法及搜索路径等；5. 实验结果分析；6. 结论；7. 提供全部源程序及软件的可执行程序。
附：实验报告格式一、实验问题二、实验目的三、实验原理四、程序框图五、实验结果及分析六、结论。
人工智能实验报告,包括八数码问题八皇后问题和tsp问题
八数码问题（一）问题描述在一个3*3的方棋盘上放置着1,2,3,4,5,6,7,8八个数码,每个数码占一格,且有一个空格。
这些数码可以在棋盘上移动，其移动规则是：与空格相邻的数码方格可以移入空格。
现在的问题是：对于指定的初始棋局和目标棋局，给出数码的移动序列。
该问题称八数码难题或者重排九宫问题。
（二）问题分析八数码问题是个典型的状态图搜索问题。
搜索方式有两种基本的方式，即树式搜索和线式搜索。
搜索策略大体有盲目搜索和启发式搜索两大类。
盲目搜索就是无“向导”的搜索，启发式搜索就是有“向导”的搜索。
1、启发式搜索由于时间和空间资源的限制，穷举法只能解决一些状态空间很小的简单问题，而对于那些大状态空间的问题，穷举法就不能胜任，往往会导致“组合爆炸”。
所以引入启发式搜索策略。
启发式搜索就是利用启发性信息进行制导的搜索。
它有利于快速找到问题的解。
由八数码问题的部分状态图可以看出，从初始节点开始，在通向目标节点的路径上，各节点的数码格局同目标节点相比较，其数码不同的位置个数在逐渐减少，最后为零。
所以，这个数码不同的位置个数便是标志一个节点到目标节点距离远近的一个启发性信息，利用这个信息就可以指导搜索。
即可以利用启发信息来扩展节点的选择，减少搜索范围，提高搜索速度。
启发函数设定。
对于八数码问题，可以利用棋局差距作为一个度量。
搜索过程中，差距会逐渐减少，最终为零，为零即搜索完成，得到目标棋局。
（三）数据结构与算法设计该搜索为一个搜索树。
为了简化问题，搜索树节点设计如下：struct Chess//棋盘{int cell[N][N];//数码数组int Value;//评估值Direction BelockDirec;//所屏蔽方向struct Chess * Parent;//父节点};int cell[N][N]; 数码数组：记录棋局数码摆放状态。
int Value; 评估值：记录与目标棋局差距的度量值。
Direction BelockDirec; 所屏蔽方向：一个屏蔽方向，防止回推。
八数码问题实验报告
八数码问题实验报告八数码问题实验报告引言：八数码问题，也被称为九宫格问题，是一种经典的数学谜题。
在一个3x3的方格中，摆放有1至8的数字，其中一个位置为空。
目标是通过交换数字的位置，将数字按照从小到大的顺序排列，最终使得空格位于最后一个位置。
本实验旨在通过编程实现八数码问题的求解，并探讨不同算法在解决该问题上的效果和优劣。
实验步骤：1. 算法选择在本次实验中，我们选择了广度优先搜索算法和A*算法作为求解八数码问题的两种不同方法。
广度优先搜索算法是一种盲目搜索算法，它通过逐层扩展搜索树，直到找到目标状态。
而A*算法则是一种启发式搜索算法，它结合了广度优先搜索和启发式函数，通过评估每个状态的代价来指导搜索过程，以找到最优解。
2. 算法实现我们使用Python语言实现了以上两种算法。
首先，我们定义了一个表示状态的类，并实现了状态的初始化、移动、判断是否达到目标状态等基本操作。
然后，我们分别编写了广度优先搜索算法和A*算法的求解函数。
在广度优先搜索算法中，我们使用队列数据结构来保存待扩展的状态，以实现逐层扩展的效果；在A*算法中，我们使用优先队列来保存待扩展的状态，并根据启发式函数的值进行优先级排序。
3. 实验结果我们使用了多个测试样例来验证两种算法的求解效果。
实验结果表明，广度优先搜索算法能够找到解，但是在面对状态空间较大的情况下，搜索时间会呈指数级增长。
而A*算法则能够更快地找到最优解，其效率相对较高。
然而，A*算法需要选择合适的启发式函数，并且对于某些特殊情况，可能会陷入局部最优解而无法找到最优解。
4. 结果分析通过对比两种算法的求解结果，我们可以发现广度优先搜索算法和A*算法在时间效率和解的质量上存在一定的差异。
广度优先搜索算法适用于状态空间较小的情况，但是在状态空间较大时效率较低；而A*算法则能够在较短的时间内找到最优解，但需要对问题进行合理的建模和启发式函数的选择。
因此，在实际应用中，我们需要根据问题的规模和特点来选择合适的算法。
人工智能-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*搜索算法性能的影响等。
人工智能实验报告 八数码
人工智能实验报告八数码人工智能实验报告八数码引言：人工智能（Artificial Intelligence，简称AI）作为一门前沿的学科，已经在各个领域展现出了巨大的应用潜力。
其中，八数码问题作为一个经典的算法问题，被广泛应用于人工智能领域。
本文将对八数码问题进行实验研究，探讨其在人工智能中的应用。
一、八数码问题的定义八数码问题是指在一个3x3的棋盘上，摆放有1至8这8个数字，其中一个格子为空。
玩家需要通过移动数字，使得棋盘上的数字按照从小到大的顺序排列，空格在最后。
八数码问题可以被抽象为一个搜索问题，即找到从初始状态到目标状态的最短路径。
二、实验方法为了解决八数码问题，我们采用了A*算法作为实验方法。
A*算法是一种启发式搜索算法，通过估计目标状态与当前状态之间的代价函数，选择最优的路径进行搜索。
在本次实验中，我们将使用曼哈顿距离作为代价函数进行搜索。
三、实验结果我们使用Python编程语言实现了八数码问题的求解算法，并进行了多组实验。
实验结果表明，A*算法在解决八数码问题上表现出了较好的效果。
在大部分情况下，A*算法能够在较短的时间内找到最优解。
四、实验讨论尽管A*算法在解决八数码问题上表现出了较好的效果，但我们也发现了一些问题。
首先，A*算法在面对复杂的八数码问题时，搜索时间会显著增加。
其次，A*算法在面对某些特定情况时，可能会陷入局部最优解，无法找到全局最优解。
这些问题需要进一步的研究和改进。
五、应用前景八数码问题作为人工智能领域的经典问题，有着广泛的应用前景。
首先，八数码问题可以被应用于游戏设计中，作为一种智能对手的算法。
其次，八数码问题的解决方法可以被应用于路径规划、图像识别等领域，提高算法的效率和准确性。
六、结论通过本次实验，我们对八数码问题进行了深入的研究和探讨。
A*算法作为一种启发式搜索算法，在解决八数码问题上表现出了较好的效果。
然而，八数码问题仍然存在一些挑战和问题，需要进一步的研究和改进。
人工智能-IDA星解八数码问题
ቤተ መጻሕፍቲ ባይዱ
问题简介
• 简介：八数码问题也称为九宫问题。在3×3的棋盘， 摆有八个棋子，每个棋子上标有1至8的某一数字， 不同棋子上标的数字不相同。棋盘上还有一个空格， 与空格相邻的棋子可以移到空格中。 • 问题：给出一个初始状态和一个目标状态，找出一 种从初始转变成目标状态的移动棋子步数最少的移 动步骤。所谓问题的一个状态就是棋子在棋盘上的 一种摆法。棋子移动后，状态就会发生改变。 • 方法：八数码问题一般使用搜索法来解。搜索法有 广度优先搜索法、深度优先搜索法、A*算法、IDA* 等。
二：如何对八数码问题进行抽象
• ①：用board[3][3]记录3*3的方格里面对应的图 像块的编号。 • ②：终止状态goal_state默认为 {1,2,3 4,5,6 7,8,0} • ③：问题即为从初始状态board到goal_state的 搜索问题，状态转移为上下左右4种移动方式
三：如何在较短的时间里求得八数码问题的 最短路径 • 这里采用IDA*(Iterative Deepening A*)算法 • 与A*相比的优势： 1. 不需要判重，不需要排序，仅用到栈，操 作简单 2. 空间需求大大减少，仅与搜索树大小成对 数关系
主界面
AI搜索界面
主要算法
• 一：如何随机生成 一个有解的八数码 问题 • 二：如何对八数码 问题进行抽象 • 三：如何在较短的 时间里求得八数码 问题的最短路径
一：如何随机生成一个有解的八数码问题 • 先默认八数码的状态为已经完成的状态， 然后随机移动n步，于是形成了一个可解的 八数码问题。 • 通常(n>100)
IDA*伪代码
估价函数
• F*(n)=g*(n)+h*(n) • G*(n):这里定义为从初始状态到当前状态所 走的步数，即深度。 • H*(n):这里定义为所有方格(不是空格)的离 家(该空格应该在的地方)的距离的和。
人工智能-八数码游戏问题
一、八数码游戏问题简介九宫排字问题(乂称八数码问题)是人工智能当中有名的难题之一。
问题是在3X3方格盘上，放有八个数码，剩下第九个为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始位置转化为目标位置。
八数码游戏二、实验目的1 .熟悉人工智能系统中的问题求解过程；2 .熟悉状态空间的盲目搜索和启发式搜索算法的应用;3 .熟悉对八数码问题的建模、求解及编程语言的应用。
三、实验的思路八数码问题：在3X3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
例如:实验八数码游戏问题(a)初始状态图 (b)目标状态图1八数码问题示意图1 .启发函数设定由八数码问题的部分状态图可以看出，从初始节点开始，在通向目标节点的路径上，各节点的数码格局同目标节点相比较，其数码不同的位置个数在逐渐减少，最后为零，因此可以把数码不同的位置个数作为标志一个节点到目标节点距离远近的一个启发性信息，利用这个信息来扩展节点的选择，减少搜索范围，提高搜索速度。
2 .搜索过程：（搜索采用广度搜索方式，利用待处理队列辅助，逐层搜索（跳过劣质节点））a 、把初始数码组压入队列；b 、从队列中取出一个数码组节点；c 、扩展子节点，即从上下左右四个方向移动空格，生成相应子节点：d 、对子节点数码组作评估，是否为优越节点，即其评估值是否小于等于其父节点加一，是则将其压入队，否则抛弃。
e 、判断压入队的子节点数码组（优越点）的评估值，为零则表示搜索完成，退出搜索；f 、跳到步骤2；四、数据结构的设计//八数码结构体 〃数码组 〃评估值，差距 〃所屏蔽方向，防止往回推到上一状态,1上2下3左4 〃父节点数码结构体typedefstnictnode(intfonn[N][N];intevalue;intudirec;右stmctnode"parent;}Graph;Giaph*Qu[MAX];〃队歹lj起始五、实验过程及代码#mclude<stdio.h>}〃设计了搜索深度范围，防止队列内存越界#include<stdlib.h>#include<tnne.h>#defineN3〃数码组大小#defineMax_Step50〃最大搜索深度#defineMAX50typedefstinctnode//八数码结构体{intform[N][N];〃数码组intevahie;//评估值intudirect;〃所屏蔽方向，防止往回推到上已状态，1上2下3左4右stiuctnode*parent;〃父节点}Graph;Graph*Qu[MAX];//队歹ijGi-aph*St[MAX];〃堆栈〃/〃/〃/打印数码组voidPrint(Graph*The_graph){mtij;if(The_gi-aph=NULL)pnntf(”图为空\n)else{pnntff\n M);for(i=0;i<N;i++)(pmitf(n|\t H);for(j=0;j<N;j++)(printff^d't'Thjgraph->fbrm[i][j]);〃遍历打印}pinitfC,\t|\n n);}pniitf(n|\t\t\t差距:%d\t|\ir：The_graph->evahie);//差距显示pnntff\n M); ))〃//〃/〃评价函数mtEvaluate(Graph*The_gi'aph,Graph*End_graph){int\T alute=O;//差E巨数mtij;fbr(i=O;i<N;i-H-){for(j=0;j<N;j++)(if(The_graph->fbmi[i]|j]!=End_gi'aph->fonn[i][j])(valute++;}}}The_giaph->evalue=x r alute;returnvalute;}/〃/〃/〃移动数码组Graph*Move(Graph*Tlie_gi'aph,mtDirect,intCreatNew_graph){ Graph*New_graph;intHasGetBlank=O;〃是否获取空格位置intAbleMove=1;〃是否可移动intfor(i=0;i<N;i++)〃获取空格坐标ij{for(j=0;j<N;j++)(if(The_graph->fbim[i][j]=0)(HasGetBlaiik=l;break;}}if(HasGetBlank=l)break;}〃prin氓”空格位置:%d,%d\n”,i,j);t户U=J；〃移动空格switch(Direct){case1://_Etj-sif(t_i<0)AbleMove=0;break;case27/Ft_i++;if(t_i>=N)AbleMove=0;break;case3://左if(U<o)AbleMove=0;break;case4://右tj++;if(tj>=N)AbleMove=0;break;}if(AbleMove==0)〃不能移动则返回原节点{returnThe_graph;)if(CreatNew_gi,aph=1){New_graph=(Graph*)malloc(sizeof(Graph));//生成节点for(x=0;x<N;x++)( fbr(y^O;y<N;y++)(New_gi,aph->fbnn[x][y]=The_graph->fomi[x][y];//目制数码组}})elseNew_graph=The_graph;}〃移动后New_graph->fdmi[i][j]=New_gi-aph->fbnn[t_i][tj];New_graph->fbnn[t_i][t_j]=O;//pnntf("移动产生的新图:\n");//Print(New_graph);retiimNew_graph;}/〃/〃/〃搜索函数Graph*Search(Graph"Begin,Graph*End){Graph*gl,*g2,*g;intStep=O;〃深度intDirect=O;〃方向inti;intfront,rear;fiont=i-eai--l-Jf队列初始化g=NULL;reai++;〃入队Qu[rear]=Begin;while(rear!=fixmt)〃队列不空{fhmHT;〃出队gl=Qu[front];“printf("开始第％d个图ont);//Pimt(gl);for(i=1;iv=4;i++)〃分别从四个方向推导出新子节点(Duect=i;if(Du-ect=g1->udirect)〃跳过屏蔽方向contmue;g2=Move(gl,Direct,1)；〃移动数码组if(g2!=gl)〃数码组是否可以移动(〃可以移动Evahiate(g2,End);〃评价新的节点〃pnntf("开始产生的第％d个图://Print(g2);if(g2->evalue<=gl->evalue+1)〃是优越节点g2->parent=gl;〃移动空格switch(Direct)〃设置屏蔽方向，防止往回推(case1://Jtg2->udirect=2;break;case2:〃下g2->udu,ect=l;break;case3:〃左g2->udkect=4;break;case4:〃右g2->udirect=3;break;)rear4-+;Qu[rear]=g2;〃存储节点到待处理队列if(g2->evalue==0)〃为0则搜索完成(g=g2；//i=5;break;)}else(丘ee(g2);〃抛弃劣质节点g2=NULL;})}if(g!=NULL)〃为0则搜索完成(if(g->evalue==O)break;Step++;〃统计深度if(Step>Max_Step)break;}}retiinig;}mtmam(mtargc?constchar*argv口){//insertcodehere...GraphBegm_graph={{{2,8,3},{1,6,4},{7,0,5}},0,0,NULL)；/*IGraphBegm_graph={{{2,8,3},{1,0,4},{7,6,5}},0,0,NULL)；GraphBegm_graph={{{2,0,1},{4,6,5},{3,7,8}},0,0,NULL)；*/〃目标数码组GraphEnd_graph={{{1,2,3},{8,0,4},{7,6,5}},0,0,NULL)；Evaluate(&Begin_gi,aph,&End_graph);//对初始的数码组评价pnntf("初始数码组:\n”)；Pnnt(&Begm_graph);pnntf("目标数码组An")；Pnnt(&End_giaph);Graph*G,*P:inttop=-l;〃图搜索G=Search(&Begm_graph,&End_graph);〃打印if(G){〃把路径倒序P=G;〃压栈while(P!=NULL)(top++;St[top]=P;P=P->parent;}pnntf(y<v<vvvvvvvvvvv搜索结^»»»»»»»»\ii H);〃弹栈打印while(top>-l)(P=St[top];top--;Prmt(P);}pniitf(n<««««««««^Mc»»»>»»»»»>^i n);}else{prmtf("搜索不到结果，深度为％dW,Max_Step);〃设计搜索深度范围主要是防止队列内存越界)retiim0;六、实验结果。
人工智能导论实验一 基于图搜索技术的八数码问题求解
广州大学学生实验报告开课学院及实验室：计算机科学与工程实验室 2020年10月14日(***报告只能为文字和图片,老师评语将添加到此处,学生请勿作答***)一、实验内容1. 分别用广度优先搜索策略、深度优先搜索策略和启发式搜索算法（至少两种）求解八数码问题；分析估价函数对启发式搜索算法的影响；探究讨论各个搜索算法的特点。
二、实验设备1. 实验设备：计算机；2. 平台：Windows操作系统，Visual C++ 6.0 / Python Anaconda三、实验步骤1. 随机生成一个八数码问题分布，设计一个可解的目标状态（要求棋盘9个位置都不同）2. 分别用广度优先搜索策略、深度优先搜索策略和至少两种启发式搜索算法求解八数码问题3. 分析估价函数对启发式搜索算法的影响4. 探究讨论各个搜索算法的特点四、分析说明（包括核心代码及解释）广度优先搜索：首先创建一个结构体node，来记录节点移动方向和扩展的节点。
struct node{int ab[3][3];//节点int direction;//方向};struct node sh[102], end;int count = 1;然后创建一个init函数来初始化棋盘起始状态和目标状态，使用for语句填写棋盘数字用loction函数确定0节点的位置，通过for语句和if语句判断sh[num].ab[i / 3][i % 3] == 0，即可得到0节点的位置Sign函数用来获取棋盘状态，将当前棋盘数字顺序生成一个数，即可得知棋盘状态。
Mobile函数用来移动0节点，先用loction函数获取0节点的位置，再通过if语句来判断0节点位置和所能移动方向，然后进行移动。
Display函数使用for语句来打印当前棋盘。
Search函数使用display函数来打印从初始状态移动到目标状态的中间状态棋盘，在while（1）语句下利用mobile函数移动0节点，直到目标状态找到或者超过寻找次数。
八数码问题,实验报告
八数码问题,实验报告八数码实验报告利用人工智能技术解决八数码游戏问题1．八数码游戏问题简介九宫排字问题（又称八数码问题）是人工智能当中有名的难题之一。
问题是在3×3方格盘上，放有八个数码，剩下第九个为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始位置转化为目标位置。
2．八数码游戏问题的状态空间法表示①建立一个只含有初始节点S0的搜索图G，把S0放入OPEN表中②建立CLOSED表，且置为空表③判断OPEN表是否为空表，若为空，则问题无解，退出④选择OPEN表中的第一个节点，把它从OPEN表移出，并放入CLOSED表中，将此节点记为节点n⑤考察节点n是否为目标节点，若是，则问题有解，成功退出。
问题的解就是沿着n到S0的路径得到。
若不是转⑥⑥扩展节点n生成一组不是n的祖先的后继节点，并将它们记为集合M，将M中的这些节点作为n的后继节点加入图G中⑦对未在G中出现过的（OPEN和CLOSED表中未出现过的）集合M中的节点, 设置一个指向父节点n的指针，并把这些节点放入OPEN表中；对于已在G中出现过的M中的节点，确定是否需要修改指向父节点的指针；对于已在G中出现过并已在closed表中的M中的节点，确定是否需要修改通向他们后继节点的指针。
⑧按某一任意方式或某种策略重排OPEN表中节点的顺序⑨转③3．八数码游戏问题的盲目搜索技术宽度优先搜索：1、定义如果搜索是以接近起始节点的程度依次扩展节点的，那么这种搜索就叫做宽度优先搜索(breadth-first search)。
2、特点这种搜索是逐层进行的；在对下一层的任一节点进行搜索之前，必须搜索完本层的所有节点。
3、宽度优先搜索算法(1) 把起始节点放到OPEN表中(如果该起始节点为一目标节点，则求得一个解答)。
(2) 如果OPEN是个空表，则没有解，失败退出；否则继续。
(3) 把第一个节点(节点n)从OPEN表移出，并把它放入CLOSED 的扩展节点表中。
人工智能实验报告-八数码（五篇模版）
人工智能实验报告-八数码（五篇模版）第一篇：人工智能实验报告-八数码《人工智能》实验一题目实验一启发式搜索算法1.实验内容：使用启发式搜索算法求解8数码问题。
⑴ 编制程序实现求解8数码问题A*算法，采用估价函数⎧⎪w(n)，f(n)=d(n)+⎨pn⎪⎩()其中：d(n)是搜索树中结点n的深度；w(n)为结点n的数据库中错放的棋子个数；p(n)为结点n的数据库中每个棋子与其目标位置之间的距离总和。
⑵ 分析上述⑴中两种估价函数求解8数码问题的效率差别，给出一个是p(n)的上界的h(n)的定义，并测试使用该估价函数是否使算法失去可采纳性。
2.实验目的熟练掌握启发式搜索A算法及其可采纳性。
3.数据结构与算法设计该搜索为一个搜索树。
为了简化问题，搜索树节点设计如下：typedef struct Node//棋盘 {//节点结构体int data[9];double f,g;struct Node * parent;//父节点}Node,*Lnode;int data[9];数码数组：记录棋局数码摆放状态。
struct Chess * Parent;父节点：指向父亲节点。
下一步可以通过启发搜索算法构造搜索树。
1、局部搜索树样例：*2、搜索过程搜索采用广度搜索方式，利用待处理队列辅助，逐层搜索（跳过劣质节点）。
搜索过程如下：（1）、把原棋盘压入队列；（2）、从棋盘取出一个节点；（3）、判断棋盘估价值，为零则表示搜索完成，退出搜索；（4）、扩展子节点，即从上下左右四个方向移动棋盘，生成相应子棋盘；（5）、对子节点作评估，是否为优越节点（子节点估价值小于或等于父节点则为优越节点），是则把子棋盘压入队列，否则抛弃；（5）、跳到步骤（2）；3、算法的评价完全能解决简单的八数码问题，但对于复杂的八数码问题还是无能为力。
现存在的一些优缺点。
1、可以改变数码规模（N），来扩展成N*N的棋盘，即扩展为N 数码问题的求解过程。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(declare (special *open*))
(declare (special *closed*))
(let (child rest tuple)
(cond ((null moves) nil)
(t (setq child (funcall (car moves) state))
(set-state-value new-state blank-row blank-col left-value)
(set-state-value new-state blank-row (- blank-col 1) '*)
(set-blank-col new-state (- blank-col 1))
(setq new-state (copy-tree state))
(setq blank-row (get-blank-row state))
(setq blank-col (get-blank-col state))
(cond ((> blank-col 0)
(setq left-value (get-state-value new-state blank-row (- blank-col 1)))
(t
(setq tuple (car *open*) )
(setq state (car tuple) )
(setq *open* (cdr *open*) )
(setq *closed* (cons tuple *closed*))
(cond ((equal state *goal*)
(setq path (get-path-from *goal*))
(setq *closed* nil )
(setq *start* start)
(setq *goal* goal)
(setq *moves* '(blank-left blank-up blank-right blank-down))
(breadth-first-search)))
(defun breadth-first-search ()
(format t "~% ~s " (car (cdr 8-puzzle-state)) )
(format t "~% ~s " (car (cdr (cdr 8-puzzle-state))) ))
(defun blank-left (state)
(let (blank-row blank-col left-value new-state)
(cons tuple rest )))))))
(defun get-path-from (state)
(declare (special *closed*))
(let (tuple parent path-1 path)
(cond ((equal state *start*) (list state) )
(setq path (reverse path))
(print-path path)
'OK)
(t
(setq children (generate-descendants state *moves*))
(setq *open* (append *open* children))
(breadth-fຫໍສະໝຸດ rst-search)))))))
( T nil)))
(defun print-path(path)
(cond ((null path) 'OK)
(t (print-state (car path) )
(print-path (cdr path) ))))
(defun print-state(8-puzzle-state)
(format t "~%~% ~s " (car 8-puzzle-state) )
(declare (special *open*))
(declare (special *closed*))
(declare (special *goal*))
(declare (special *moves*))
(let (state tuple children path)
(cond ((null *open*) 'FAIL!)
(declare (special *moves*))
(declare (special *start*))
(declare (special *goal*))
(let (tuple)
(setq tuple (cons start '(nil)) )
(setq *open* (list tuple) )
(defun get-state-tuple (state tuple-list)
(assoc state tuple-list :test #'equal))
(defun exist (state tuple-list)
(cond ((assoc state tuple-list :test #'equal) T)
(setq rest (generate-descendants state (cdr moves)))
(cond ((null child) rest)
((exist child *open*) rest )
((exist child *closed*) rest )
(t (setq tuple (cons child (list state)) )
人工智能上机实验二八数码问题的求解策略
1、广度优先算法程序截图：
2、最佳优先算法程序截图：
（接上图）
3、程序代码：
①广度优先算法：
(defun init-search (start goal)
(declare (special *open*))
(declare (special *closed*))
(t
(setq tuple (get-state-tuple state *closed*) )
(setq parent (car (cdr tuple)) )
(setq path-1 (get-path-from parent) )
(setq path (cons state path-1))))))