八数码问题实验报告讲解
八数码问题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)。
八数码问题 实验报告
八数码问题实验报告八数码问题实验报告引言：八数码问题是一种经典的数学难题，在计算机科学领域有着广泛的研究和应用。
本实验旨在通过探索八数码问题的解法，深入理解该问题的本质，并通过实验结果评估不同算法的效率和准确性。
一、问题描述：八数码问题是一个在3×3的棋盘上，由1至8的数字和一个空格组成的拼图问题。
目标是通过移动棋盘上的数字，使得棋盘上的数字排列按照从小到大的顺序排列，最终形成如下的目标状态：1 2 34 5 67 8二、解法探索：1. 深度优先搜索算法：深度优先搜索算法是一种经典的解决拼图问题的方法。
该算法通过不断尝试所有可能的移动方式，直到找到目标状态或者无法再继续移动为止。
实验结果显示，该算法在八数码问题中能够找到解，但由于搜索空间庞大，算法的时间复杂度较高。
2. 广度优先搜索算法：广度优先搜索算法是另一种常用的解决八数码问题的方法。
该算法通过逐层扩展搜索树，从初始状态开始，逐步扩展所有可能的状态，直到找到目标状态。
实验结果显示，该算法能够找到最短路径的解，但同样面临搜索空间庞大的问题。
3. A*算法：A*算法是一种启发式搜索算法，结合了深度优先搜索和广度优先搜索的优点。
该算法通过使用一个估价函数来评估每个搜索状态的优劣，并选择最有希望的状态进行扩展。
实验结果显示，A*算法在八数码问题中表现出色，能够高效地找到最优解。
三、实验结果与分析：通过对深度优先搜索、广度优先搜索和A*算法的实验，得出以下结论：1. 深度优先搜索算法虽然能够找到解，但由于搜索空间庞大，时间复杂度较高，不适用于大规模的八数码问题。
2. 广度优先搜索算法能够找到最短路径的解，但同样面临搜索空间庞大的问题，对于大规模问题效率较低。
3. A*算法在八数码问题中表现出色，通过合理的估价函数能够高效地找到最优解，对于大规模问题具有较好的效果。
四、结论与展望：本实验通过对八数码问题的解法探索，深入理解了该问题的本质，并评估了不同算法的效率和准确性。
八数码 实验报告
八数码实验报告八数码实验报告引言：八数码，也称为滑块拼图，是一种经典的数字游戏。
在这个游戏中，玩家需要通过移动数字方块，将它们按照从小到大的顺序排列。
本次实验旨在通过编写八数码游戏的程序，探索并实践算法设计与实现的过程。
实验过程：1. 游戏规则设计在开始编写程序之前，首先需要明确游戏的规则。
八数码游戏的规则如下：- 有一个3x3的方格，其中有8个方块分别带有数字1到8，还有一个空白方块。
- 玩家可以通过移动数字方块，将它们按照从小到大的顺序排列。
- 移动的方式是将数字方块与空白方块进行交换，只能上下左右移动。
2. 程序设计基于以上规则，我们开始设计程序。
首先，我们需要实现游戏界面的显示与交互。
通过使用图形界面库，我们可以方便地创建一个可视化的游戏界面。
在界面中，每个数字方块都是一个可交互的按钮，玩家可以通过点击按钮来移动数字方块。
接下来，我们需要实现游戏逻辑的处理。
当玩家点击一个数字方块时，程序需要判断该方块是否与空白方块相邻，如果相邻，则进行交换。
同时，程序还需要判断玩家是否已经成功完成了游戏，即数字方块是否已经按照从小到大的顺序排列。
为了实现这些功能，我们可以使用算法来进行判断和计算。
例如，可以通过遍历每个方块，检查其周围是否有空白方块，从而确定是否可以进行移动。
另外，可以使用排序算法来判断数字方块是否已经按照顺序排列。
3. 算法实现在实现算法时，我们可以选择不同的方法。
例如，可以使用深度优先搜索算法来寻找解决方案。
深度优先搜索算法通过递归地尝试每一种移动方式，直到找到一个可行的解决方案。
另外，还可以使用启发式搜索算法，如A*算法，来提高搜索效率。
在本次实验中，我们选择使用A*算法来解决八数码问题。
A*算法通过估计每个状态与目标状态的距离，选择最有可能导致解决方案的移动方式。
通过使用合适的启发函数，A*算法可以在较短的时间内找到一个最优解。
4. 实验结果经过程序的编写和测试，我们成功地实现了八数码游戏。
8数码实验报告
8数码实验报告8数码实验报告引言：数码技术在现代社会中扮演着重要的角色，它的应用范围广泛，从家庭到工业领域都有着不可替代的作用。
为了更好地了解和掌握数码技术的原理和应用，我们进行了一系列的实验。
本报告将详细介绍我们进行的8个数码实验，包括实验目的、实验原理、实验步骤、实验结果和实验总结。
实验一：二进制与十进制转换实验目的：通过将二进制数转换为十进制数，加深对二进制和十进制之间转换关系的理解。
实验原理：二进制数是由0和1组成的数，而十进制数是由0-9这10个数字组成的数。
二进制数转换为十进制数的方法是将每一位的权值与对应位上的数字相乘，再将结果相加。
实验步骤：将给定的二进制数转换为十进制数，并记录结果。
实验结果：通过实验，我们成功地将二进制数转换为了十进制数，并验证了转换的正确性。
实验总结：这个实验帮助我们更好地理解了二进制和十进制之间的转换关系，为后续的实验打下了基础。
实验二：逻辑门电路实验实验目的：通过搭建逻辑门电路，了解逻辑门的基本原理和功能。
实验原理：逻辑门是由晶体管或其他电子元件组成的电路，根据输入信号的不同，产生不同的输出信号。
常见的逻辑门有与门、或门、非门等。
实验步骤：根据实验要求，搭建逻辑门电路，并测试输入和输出信号。
实验结果：通过实验，我们成功地搭建了逻辑门电路，并观察到了不同输入信号下的输出信号变化。
实验总结：逻辑门电路是数字电路的基础，通过这个实验，我们对逻辑门的原理和功能有了更深入的了解。
实验三：数码显示实验实验目的：了解数码显示器的原理和工作方式。
实验原理：数码显示器是一种能够显示数字和字符的设备，它由多个发光二极管（LED）组成。
每个发光二极管代表一个数字或字符，通过控制不同的发光二极管点亮或熄灭，可以显示不同的数字或字符。
实验步骤：通过控制数码管的电平，显示指定的数字或字符。
实验结果：通过实验，我们成功地控制了数码管的显示，实现了指定数字或字符的显示效果。
实验总结：数码显示器是一种常见的输出设备，通过这个实验，我们对数码显示器的工作原理和控制方式有了更深入的理解。
八数码实验报告
八数码实验报告八数码实验报告引言：八数码，也被称为滑块拼图，是一种经典的益智游戏。
在这个实验中，我们将探索八数码问题的解决方案，并分析其算法的效率和复杂性。
通过这个实验，我们可以深入了解搜索算法在解决问题中的应用，并且探讨不同算法之间的优劣势。
1. 问题描述：八数码问题是一个在3x3的方格上进行的拼图游戏。
方格中有8个方块，分别标有1到8的数字，还有一个空方块。
游戏的目标是通过移动方块，将它们按照从左上角到右下角的顺序排列。
2. 算法一：深度优先搜索（DFS）深度优先搜索是一种经典的搜索算法，它从初始状态开始，不断地向前搜索，直到找到目标状态或者无法继续搜索为止。
在八数码问题中，深度优先搜索会尝试所有可能的移动方式，直到找到解决方案。
然而，深度优先搜索在解决八数码问题时存在一些问题。
由于搜索的深度可能非常大，算法可能会陷入无限循环，或者需要很长时间才能找到解决方案。
因此，在实际应用中，深度优先搜索并不是最优的选择。
3. 算法二：广度优先搜索（BFS）广度优先搜索是另一种常用的搜索算法，它从初始状态开始，逐层地向前搜索，直到找到目标状态。
在八数码问题中，广度优先搜索会先尝试所有可能的一步移动，然后再尝试两步移动，依此类推，直到找到解决方案。
与深度优先搜索相比，广度优先搜索可以保证找到最短路径的解决方案。
然而，广度优先搜索的时间复杂度较高，尤其是在搜索空间较大时。
因此，在实际应用中，广度优先搜索可能不太适合解决八数码问题。
4. 算法三：A*算法A*算法是一种启发式搜索算法，它在搜索过程中利用了问题的启发信息，以提高搜索效率。
在八数码问题中，A*算法会根据每个状态与目标状态之间的差异，选择最有可能的移动方式。
A*算法通过综合考虑每个状态的实际代价和启发式估计值，来评估搜索路径的优劣。
通过选择最优的路径，A*算法可以在较短的时间内找到解决方案。
然而，A*算法的实现较为复杂，需要合适的启发函数和数据结构。
八个数字问题实验报告.doc
八个数字问题实验报告. 《八数码问题》实验报告首先，实验的目的:熟悉启发式搜索算法。
二、实验内容:启发式搜索算法用于解决8位数问题。
编制了程序，实现了解决8位数问题的算法。
采用评估功能，其中:是搜索树中节点的深度；在节点数据库中放错位置的件数；这是每个棋子与其在节点数据库中的目标位置之间距离的总和。
三、实验原理:1.问题描述:八位数问题也被称为九宫问题。
在3×3的棋盘上，有八个棋子，每一个棋子都标有一定的1到8的数字，不同棋子上标的数字是不同的。
棋盘上还有一个空格(用数字0表示)，与空格相邻的棋子可以移动到空格中。
要解决的问题是: 给定初始状态和目标状态，找出从初始状态到目标状态移动次数最少的移动步骤。
所谓问题的一种状态是棋盘上棋子的排列。
解决八位数问题实际上是找出一系列从初始状态到目标状态的中间过渡状态。
2.原则描述:启发式搜索(1)原理启发式搜索是评估每个搜索在状态空间中的位置以获得最佳位置，然后从这个位置搜索到目标。
这样，可以省略大量不必要的搜索路径，并且提高了效率。
在启发式搜索中，位置的评估非常重要。
不同的评估会产生不同的效果。
(2)评估函数计算节点的评估函数，可分为两部分:1.成本已经支付(从开始节点到当前节点)；2.要支付的价格(当前节点到目标节点)。
节点n的评估函数被定义为从初始节点通过n到目标节点的路径的最小成本的估计值，即=。
是从初始节点到达当前节点n的实际成本；是从节点n到目标节点的最佳路径的估计开销。
比例越大，它越倾向于先搜索宽度或同等成本。
相反，比例越大，启发式性能越强。
(3)算法描述:(1)将起始节点S放入OPEN表中，计算节点S的值；(2)如果OPEN为空表，则无法退出且没有解决方案；(3)从OPEN表中选择具有最小值的节点。
如果多个节点具有相同的值，当其中一个节点是目标节点时，选择目标节点；否则，任意一个节点被选为节点；(4)从OPEN表中移除节点，并将其放入CLOSED扩展节点表中；(5)如果它是目标节点，它成功退出并获得解决方案；⑥扩展节点以生成其所有后续节点。
八数码问题求解--实验报告讲解-共16页
实验报告一、实验问题八数码问题求解二、实验软件VC6.0 编程语言或其它编程语言三、实验目的1. 熟悉人工智能系统中的问题求解过程；2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用；3. 熟悉对八数码问题的建模、求解及编程语言的应用。
四、实验数据及步骤（一、）实验内容八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
2 83 1 2 31 4 8 47 6 5 7 6 5(a) 初始状态(b) 目标状态图1 八数码问题示意图（二、）基本数据结构分析和实现1.结点状态我采用了struct Node数据类型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; 2.发生器函数定义的发生器函数由以下的四种操作组成：(1)将当前状态的空格上移Node node_up;Assign(node_up, index);//向上扩展的节点int dist_up = MAXDISTANCE;(2)将当前状态的空格下移Node node_down;Assign(node_down, index);//向下扩展的节点int dist_down = MAXDISTANCE;(3)将当前状态的空格左移Node node_left;Assign(node_left, index);//向左扩展的节点int dist_left = MAXDISTANCE;(4)将当前状态的空格右移Node node_right;Assign(node_right, index);//向右扩展的节点int dist_right = MAXDISTANCE;通过定义结点状态和发生器函数，就解决了8数码问题的隐式图的生成问题。
人工智能实验一_八数码问题
用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
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步，成功从初始状态到目标状态的最短路径。
人工智能实验报告,包括八数码问题八皇后问题和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; 所屏蔽方向：一个屏蔽方向，防止回推。
八数码问题实验报告讲解
《八数码问题》实验报告一、实验目的：熟练掌握启发式搜索A *算法。
二、实验内容：使用启发式搜索算法求解8数码问题。
编制程序实现求解8数码问题A *算法，采用估价函数()()()()w n f n d n p n ⎧⎪=+⎨⎪⎩， 其中：()d n 是搜索树中结点n 的深度；()w n 为结点n 的数据库中错放的棋子个数；()p n 为结点n 的数据库中每个棋子与其目标位置之间的距离总和。
三、实验原理：1. 问题描述：八数码问题也称为九宫问题。
在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。
棋盘上还有一个空格（以数字0来表示），与空格相邻的棋子可以移到空格中。
要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
所谓问题的一个状态就是棋子在棋盘上的一种摆法。
解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
2. 原理描述：启发式搜索（1）原理启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。
这样可以省略大量无谓的搜索路径，提高了效率。
在启发式搜索中，对位置的估价是十分重要的。
采用了不同的估价可以有不同的效果。
（2）估价函数计算一个节点的估价函数，可以分成两个部分：1、 已经付出的代价（起始节点到当前节点）；2、 将要付出的代价（当前节点到目标节点）。
节点n 的估价函数)(n f 定义为从初始节点、经过n 、到达目标节点的路径的最小代价的估计值，即)(*n f = )(*n g + )(*n h 。
)(*n g 是从初始节点到达当前节点n 的实际代价；)(*n h 是从节点n 到目标节点的最佳路径的估计代价。
)(*n g 所占的比重越大，越趋向于宽度优先或等代价搜索；反之，)(*n h 的比重越大，表示启发性能就越强。
八数码问题实验报告
八数码问题实验报告八数码问题实验报告引言：八数码问题，也被称为九宫格问题，是一种经典的数学谜题。
在一个3x3的方格中，摆放有1至8的数字，其中一个位置为空。
目标是通过交换数字的位置，将数字按照从小到大的顺序排列，最终使得空格位于最后一个位置。
本实验旨在通过编程实现八数码问题的求解，并探讨不同算法在解决该问题上的效果和优劣。
实验步骤：1. 算法选择在本次实验中，我们选择了广度优先搜索算法和A*算法作为求解八数码问题的两种不同方法。
广度优先搜索算法是一种盲目搜索算法，它通过逐层扩展搜索树，直到找到目标状态。
而A*算法则是一种启发式搜索算法，它结合了广度优先搜索和启发式函数，通过评估每个状态的代价来指导搜索过程，以找到最优解。
2. 算法实现我们使用Python语言实现了以上两种算法。
首先，我们定义了一个表示状态的类，并实现了状态的初始化、移动、判断是否达到目标状态等基本操作。
然后，我们分别编写了广度优先搜索算法和A*算法的求解函数。
在广度优先搜索算法中，我们使用队列数据结构来保存待扩展的状态，以实现逐层扩展的效果；在A*算法中，我们使用优先队列来保存待扩展的状态，并根据启发式函数的值进行优先级排序。
3. 实验结果我们使用了多个测试样例来验证两种算法的求解效果。
实验结果表明，广度优先搜索算法能够找到解，但是在面对状态空间较大的情况下，搜索时间会呈指数级增长。
而A*算法则能够更快地找到最优解，其效率相对较高。
然而，A*算法需要选择合适的启发式函数，并且对于某些特殊情况，可能会陷入局部最优解而无法找到最优解。
4. 结果分析通过对比两种算法的求解结果，我们可以发现广度优先搜索算法和A*算法在时间效率和解的质量上存在一定的差异。
广度优先搜索算法适用于状态空间较小的情况，但是在状态空间较大时效率较低；而A*算法则能够在较短的时间内找到最优解，但需要对问题进行合理的建模和启发式函数的选择。
因此，在实际应用中，我们需要根据问题的规模和特点来选择合适的算法。
八数码问题实验报告
八数码问题实验报告引言八数码问题是一个著名的数学问题，也是一个经典的搜索算法应用场景。
该问题是在一个3x3的棋盘上，分布着1至8这8个数字，其中一个格子是空白的。
目标是通过交换棋盘上的数字，使得棋盘上的数字按照从小到大的顺序排列，空白格子位于最后。
本实验报告将介绍八数码问题的背景、具体实验步骤以及实验结果分析。
实验步骤1.定义状态空间和目标状态：将八数码问题抽象成一个状态空间图。
每个状态表示一个棋盘布局，目标状态是数字按照从小到大的顺序排列，空白格子位于最后。
2.实现状态的表示：使用一个3x3的二维数组来表示棋盘状态，空白格子用0表示。
3.实现状态转移函数：定义合法的移动操作，例如将一个数字移动到空白格子的位置。
根据当前状态和移动操作，得到下一个状态。
4.实现启发式函数：设计一个启发式函数来评估当前状态和目标状态之间的距离。
常用的启发式函数有曼哈顿距离和错位数。
5.实现搜索算法：选择合适的搜索算法，例如A算法或IDA算法。
根据当前状态和目标状态，通过搜索算法找到最优解。
6.实验结果分析：运行实验程序，记录搜索所需的时间和搜索路径长度。
分析不同启发式函数和搜索算法对实验结果的影响。
实验结果分析本次实验中，我们选择了A*算法作为搜索算法，曼哈顿距离作为启发式函数。
经过多次实验，我们发现实验结果受到初始状态的影响较大。
对于某些初始状态，搜索算法可以在较短的时间内找到最优解，而对于其他初始状态，搜索时间较长。
这是因为八数码问题的状态空间非常庞大，搜索算法需要遍历大量的状态才能找到最优解。
另外，我们还发现启发式函数的选择对搜索效率有一定的影响。
曼哈顿距离作为一种常用的启发式函数，可以提供较好的搜索效果。
而对于某些特定的初始状态，如果选择了错误的启发式函数，可能会导致搜索算法无法找到最优解。
在实验过程中，我们还发现A算法在某些情况下会陷入局部最优解，而无法找到全局最优解。
这是因为A算法的搜索过程是基于启发式函数的估计值，存在一定的不确定性。
人工智能实验报告 八数码
人工智能实验报告八数码人工智能实验报告八数码引言：人工智能（Artificial Intelligence，简称AI）作为一门前沿的学科，已经在各个领域展现出了巨大的应用潜力。
其中，八数码问题作为一个经典的算法问题，被广泛应用于人工智能领域。
本文将对八数码问题进行实验研究，探讨其在人工智能中的应用。
一、八数码问题的定义八数码问题是指在一个3x3的棋盘上，摆放有1至8这8个数字，其中一个格子为空。
玩家需要通过移动数字，使得棋盘上的数字按照从小到大的顺序排列，空格在最后。
八数码问题可以被抽象为一个搜索问题，即找到从初始状态到目标状态的最短路径。
二、实验方法为了解决八数码问题，我们采用了A*算法作为实验方法。
A*算法是一种启发式搜索算法，通过估计目标状态与当前状态之间的代价函数，选择最优的路径进行搜索。
在本次实验中，我们将使用曼哈顿距离作为代价函数进行搜索。
三、实验结果我们使用Python编程语言实现了八数码问题的求解算法，并进行了多组实验。
实验结果表明，A*算法在解决八数码问题上表现出了较好的效果。
在大部分情况下，A*算法能够在较短的时间内找到最优解。
四、实验讨论尽管A*算法在解决八数码问题上表现出了较好的效果，但我们也发现了一些问题。
首先，A*算法在面对复杂的八数码问题时，搜索时间会显著增加。
其次，A*算法在面对某些特定情况时，可能会陷入局部最优解，无法找到全局最优解。
这些问题需要进一步的研究和改进。
五、应用前景八数码问题作为人工智能领域的经典问题，有着广泛的应用前景。
首先，八数码问题可以被应用于游戏设计中，作为一种智能对手的算法。
其次，八数码问题的解决方法可以被应用于路径规划、图像识别等领域，提高算法的效率和准确性。
六、结论通过本次实验，我们对八数码问题进行了深入的研究和探讨。
A*算法作为一种启发式搜索算法，在解决八数码问题上表现出了较好的效果。
然而，八数码问题仍然存在一些挑战和问题，需要进一步的研究和改进。
八数码问题-实验报告(含源码)
人工智能基础实验报告题目：八数码问题一、内容 (2)二、目的 (2)三、实验设计思想和流程 (2)四、主要数据结构及符号说明 (3)五、程序初值及运行结果 (5)附录（源代码及注释） (6)一、内容八数码问题由8个编号1~8并放在3*3方格棋盘上的可走动的棋子组成。
棋盘上有一个格是空的，以便可以让空格周围的棋子走进空格，这也可以理解为移动空格。
给出起始状态和目标状态。
用A*算法求解出移动的路径。
二、目的1、学会用状态空间法来进行知识表示2、理解A*算法三、实验设计思想和流程1.八数码问题的状态表示八数码问题的一个状态就是八个数字在棋盘上的一种放法。
每个棋子用它上面所标的数字表示，并用0表示空格，这样就可以将棋盘上棋子的一个状态存储在一个二维数组中。
2、结点扩展规则搜索就是按照一定规则扩展已知结点，直到找到目标结点或所有结点都不能扩展为止。
八数码问题的结点扩展应当遵守棋子的移动规则。
按照棋子移动的规则，每一次可以将一个与空格相邻棋子移动到空格中，实际上可以看作是空格作相反移动。
空格移动的方向可以是右、下、左、上，当然不能移出边界。
3、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)的近似，也就是用g(n)代替g'(n)，h(n)代替h'(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*算法。
人工智能八数码游戏
实验一：八数码游戏问题一、八数码游戏问题简介九宫排字问题(又称八数码问题)是人工智能当中有名的难题之一。
问题是在3X3方格盘上，放有八个数码，剩下第九个为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始位置转化为目标位置。
(a)初始状态小)目标状态图八数码游戏二、实验目的1.熟悉人工智能系统中的问题求解过程；2.熟悉状态空间的盲目搜索和启发式搜索算法的应用;3.熟悉对八数码问题的建模、求解及编程语言的应用。
三、实验的思路八数码问题：在3X3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
例如:(a)初始状态图1八数码问题示意图1 .启发函数设定由八数码问题的部分状态图可以看出，从初始节点开始，在通向目标节点的 路径上，各节点的数码格局同目标节点相比较，其数码不同的位置个数在逐渐减 少，最后为零，因此可以把数码不同的位置个数作为标志一个节点到目标节点距 离远近的一个启发性信息，利用这个信息来扩展节点的选择，减少搜索范围，提 高搜索速度。
2 .搜索过程：（搜索采用广度搜索方式，利用待处理队列辅助，逐层搜索（跳过 劣质节点））a 、把初始数码组压入队列；b 、从队列中取出一个数码组节点；c 、扩展子节点，即从上下左右四个方向移动空格，生成相应子节点：d 、对子节点数码组作评估，是否为优越节点，即其评估值是否小于等于其 父节点加一，是则将其压入队，否则抛弃。
e 、判断压入队的子节点数码组（优越点）的评估值，为零则表示搜索完成， 退出搜索；f 、跳到步骤2；四、数据结构的设计//八数码结构体 //数码组 //评估值，差距//所屏蔽方向，防止往回推到上一状态,1上2下3左4//父节点数码结构体typedef struct node(int form[N][N];int evalue;int udirec; 右 struct node *parent;}Graph;Graph *Qu[MAX];//队列Graph *St[MAX];//堆栈起始成功是否有后继节点为目标节点？... 是否open 表为空表？ ..否 否 是是—工失败扩展节点n ,把其后裔放入open 表的前头把open 表中的第一个节点n移入close 表把s 放入open 表五、实验过程及代码#include <stdio.h> } 〃设计了搜索深度范围，防止队列内存越界#include <stdlib.h> #include <time.h>#define N 3 〃数码组大小#define Max_Step 50 //最大搜索深度#define MAX 50typedef struct node//八数码结构体( int form[N][N];//数码组int evalue;//评估值int udirect;〃所屏蔽方向，防止往回推到上已状态，1上2下3左4右struct node "parentJ/父节点}Graph;Graph *Qu[MAX]; 〃队列Graph *St[MAX]; 〃堆栈/////////打印数码组void Print(Graph *The_graph) ( int i,j; if(The_graph==NULL) printf("图为空\n"); else ( printf(" -------------------------- \n");for(i=0;i<N;i++) ( printf("|\t"); for(j=0;j<N;j++)( printf("%d\t",The_graph->form[i][j]);/遍历打印} printf("\t|\n");} printf("|\t\t\t 差距:％d\t|\n",The_graph->evalue);//差距显示printf(" ----------------- \n");〃〃〃〃/评价函数int Evaluate(Graph *The_graph,Graph *End_graph)(int 丫21a©=0;//差距数int i,j;for(i=0;i<N;i++)(for(j=0;j<N;j++)(if(The_graph->form[i][j]!=End_graph->form[i][j])(valute++;)))The_graph->evalue=valute;return valute;)/////////移动数码组Graph *Move(Graph *The_graph,int Direct,int CreatNew_graph) (Graph *New_graph;int HasGetBlank=0;//是否获取空格位置int Ab1eMove=1;//是否可移动int i,j,t_i,t_j,x,y;for(i=0;i<N;i++)//获取空格坐标i,j(for(j=0;j<N;j++)(if(The_graph->form[i][j]==0)(HasGetBlank=1;break;))if(HasGetBlank==1)break;)//printf("空格位置:％d,%d\n”,i,j);t_i=i;t_j=j;〃移动空格switch(Direct) (case 1:〃上t_i--；if(t_i<0)AbleMove=0;break;case 2:〃下t_i++;if(t_i>=N)AbleMove=0;break;case 3:〃左t_j--;if(t_j<0)AbleMove=0;break;case 4:〃右t_j++; if(t_j>=N)AbleMove=0; break;)if(AbleMove==0)//不能移动则返回原节点(return The_graph;)if(CreatNew_graph==1)(New_graph=(Graph *)malloc(sizeof(Graph));//生成节点for(x=0;x<N;x++) ( for(y=0;y<N;y++)(New_graph->form[x][y]=The_graph->form[x][y];/复制数码组)) else(New_graph=The_graph;)〃移动后New_graph->form[i][j]=New_graph->form[t_i][t_j];New_graph->form[t_i][t_j]=0;//printfC移动产生的新图:\n");//Print(New_graph);return New_graph;)/////////搜索函数Graph *Search(Graph *Begin,Graph *End) (Graph *g1,*g2,*g;int Step=0;//^^int Direct=0;//方向int i;int front,rear;front=rear=-1;//队列初始化g=NULL;rear++;//A^Qu[rear]=Begin;while(rear!=front)//队列不空(front++;//出队g1=Qu[front];//printf("开始第％d 个图:\n",front);//Print(g1);代班=1;1<=4计+)//分别从四个方向推导出新子节点(Direct=i;if(Direct==g1->udirect)//跳过屏蔽方向continue;g2=Move(g1, Direct, 1);//移动数码组if(g2!=g1)//数码组是否可以移动(〃可以移动Evaluate(g2, End);//评价新的节点//printfC开始产生的第％d个图:\n",i);//Print(g2);if(g2->evalue<=g1->evalue+1) (〃是优越节点g2->parent=g1;〃移动空格switch①irect)//设置屏蔽方向，防止往回推(case 1://上g2->udirect=2;break;case 2://下g2->udirect=1;break;case 3://左g2->udirect=4;break;case 4://右g2->udirect=3; break;)rear++;Qu[rear]=g2;//存储节点到待处理队列if(g2->evalue==0)〃为0 则搜索完成(g=g2;//i=5;break;))else(free(g2);//抛弃劣质节点g2=NULL;)))if(g!=NULL)〃为0则搜索完成(if(g->evalue==0)(break;Step++;//统计深度if(Step>Max_Step) (break;))return g;) int main (int argc, const char * argv[])(// insert code here...Graph Begin_graph={{{2,8,3},{1,6,4},{7,0,5}},0,0,NULL);/*Graph Begin_graph={{{2,8,3},{1,0,4},{7,6,5}},0,0,NULL };Graph Begin_graph={{{2,0,1},{4,6,5},{3,7,8}},0,0,NULL};*///目标数码组Graph End_graph={{{1,2,3},{8,0,4},{7,6,5}},0,0,NULL };Evaluate(&Begin_graph, &End_graph);//对初始的数码组评价printf("初始数码组:\n");Print(&Begin_graph);printf("目标数码组:\n");Print(&End_graph);Graph *G,*P;int top=-1;〃图搜索G=Search(&Begin_graph, &End_graph);〃打印if(G)(〃把路径倒序P=G;〃压栈while(P!=NULL)(top++;St[top]=P;P=P->parent;}printf("vvvvvvvvvvvvvvv 搜索结果〃弹栈打印while(top>-l)(P=St[top];top-;Print(P);}printf("««««««««<^^»»»»»»»»»\n"); } else(printf("搜索不到结果，深度为％d\n",Max_Step);〃设计搜索深度范围主要是防止队列内存越界return 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)。
《八数码问题》实验报告一、实验目的：熟练掌握启发式搜索A *算法。
二、实验内容：使用启发式搜索算法求解8数码问题。
编制程序实现求解8数码问题A *算法，采用估价函数()()()()w n f n d n p n ⎧⎪=+⎨⎪⎩， 其中：()d n 是搜索树中结点n 的深度；()w n 为结点n 的数据库中错放的棋子个数；()p n 为结点n 的数据库中每个棋子与其目标位置之间的距离总和。
三、实验原理：1. 问题描述：八数码问题也称为九宫问题。
在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。
棋盘上还有一个空格（以数字0来表示），与空格相邻的棋子可以移到空格中。
要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
所谓问题的一个状态就是棋子在棋盘上的一种摆法。
解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
2. 原理描述：启发式搜索 （1）原理启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。
这样可以省略大量无谓的搜索路径，提高了效率。
在启发式搜索中，对位置的估价是十分重要的。
采用了不同的估价可以有不同的效果。
（2）估价函数计算一个节点的估价函数，可以分成两个部分： 1、 已经付出的代价（起始节点到当前节点）； 2、 将要付出的代价（当前节点到目标节点）。
节点n 的估价函数)(n f 定义为从初始节点、经过n 、到达目标节点的路径的最小代价的估计值，即)(*n f = )(*n g + )(*n h 。
)(*n g 是从初始节点到达当前节点n 的实际代价； )(*n h 是从节点n 到目标节点的最佳路径的估计代价。
)(*n g 所占的比重越大，越趋向于宽度优先或等代价搜索；反之，)(*n h 的比重越大，表示启发性能就越强。
（3）算法描述：① 把起始节点S 放到OPEN 表中，并计算节点S 的)(S f ； ② 如果OPEN 是空表，则失败退出，无解；③ 从OPEN 表中选择一个f 值最小的节点i 。
如果有几个节点值相同，当其中有一个 为目标节点时，则选择此目标节点；否则就选择其中任一个节点作为节点i ；④ 把节点i 从 OPEN 表中移出，并把它放入 CLOSED 的已扩展节点表中； ⑤ 如果i 是个目标节点，则成功退出，求得一个解；⑥ 扩展节点i ，生成其全部后继节点。
对于i 的每一个后继节点j ：计算)(j f ；如果j 既不在OPEN 表中，又不在CLOCED 表中，则用估价函数f 把 它添入OPEN 表中。
从j 加一指向其父节点i 的指针，以便一旦找到目标节点时记住一个解答路径；如果j 已在OPEN 表或CLOSED 表中，则比较刚刚对j 计算过的f 和前面计算过的该节点在表中的f 值。
如果新的f 较小，则(I)以此新值取代旧值。
(II)从j 指向i ，而不是指向他的父节点。
(III)如果节点j 在CLOSED 表中，则把它移回OPEN 表中。
⑦ 转向②，即GOTO ②。
（3）算法流程图：四、实验结果输入矩阵：目标矩阵：283123145804760765五、实验小结通过本次试验，我对启发式搜索有了更加深入的了解。
在实验中，通过对两种启发式搜索所扩在的节点数来看，)(n p 看来比)(n 更加有效，能在复杂情况下求得更加优质的解，避免不必要的节点的扩展。
所以，要更好地定义一个估价函数还有待深入讨论。
源代码：#include"stdio.h"#define num 3 //宏定义数码的行列数为3/*显示当前待调整数码矩阵*/ void show(int begin[num][num]) { for(int i = 0; i < num; i++) { for(int j = 0; j < num; j++)printf("%d ", begin[i][j]);printf("\n");}printf("\n");}/*交换数码中的begin[row_one][column_one] 与begin[row_two][column_two] 这两个数*/void exchange(int begin[num][num], int row_one, int column_one, int row_two, int column_two) {int temp;temp = begin[row_two][column_two] ;begin[row_two][column_two] = begin[row_one][column_one];begin[row_one][column_one] = temp;}/*判断待调整的数码与最终数码相比正确位置数码的个数*/int judge(int begin[num][num], int end[num][num]){int count=0; //count记录数码中正确位置的个数for(int i = 0; i < num; i++) //检查当前图形的正确度for(int j = 0; j < num; j++){if(begin[i][j] == end[i][j] && end[i][j] != 0)count++;}return count; //返回数码中正确位置的个数}/* 将待调整数码从开始位置移动到终止位置，并将其过程输出*/int yidong(int begin[num][num], int end[num][num], int right, int jishu, int ji_shu[50][3][3], int biaoji, int row, int column) //biaoji存储上一轮移动的反方向代号{int temp_zhi;show(begin); //显示数组矩阵if(jishu >= 20)return 0;int node; //,node为标记int temp; //存储当前待调整数码正确的个数for(int q=0; q<jishu; q++) //检查交换后的end[][]图形是否先前已经遍历过了{node = 1;for(int w=0; w<num && node; w++)for(int r=0; r<num && node; r++)if(ji_shu[q][w][r] != begin[w][r])node = 0;if(node == 1) //如果先前遍历过，返回0{return 0;}}for(int i = 0; i < num; i++)for(int j = 0; j < num; j++)ji_shu[jishu][i][j] = begin[i][j];if(right == num * num - 1) //如果待调整数码与最终数码完全相同时，返回1return 1;if(row > 0 && biaoji != 0) //存储0的位置不是在第一行{exchange(begin, row - 1, column, row , column); //将0与其上面的元素交换存储位置temp = judge(begin, end);if(temp < right) //如果交换后正确数码的个数不大于原来正确数码的个数exchange(begin, row - 1, column, row , column); //再将其交换回来else if(temp >= right) //如果交换后正确数码的个数大于或等于原来正确数码的个数{temp_zhi = yidong(begin, end, temp, jishu+1, ji_shu, 2, row-1, column);if( temp_zhi == 1) //进行下一步的移动return 1;exchange(begin, row - 1, column, row , column); //再将其交换回来}}if(column > 0 && biaoji != 1){exchange(begin, row, column - 1, row , column); //将0与其左边的元素交换存储位置temp = judge(begin, end);if(temp < right)exchange(begin, row, column - 1, row , column);else if(temp >= right){temp_zhi = yidong(begin, end, temp, jishu+1, ji_shu ,3, row, column - 1);if(temp_zhi == 1)return 1;exchange(begin, row, column - 1, row , column);}}if(row < num-1 && biaoji != 2){exchange(begin, row + 1, column, row , column); //将0与其下面的元素交换存储位置temp = judge(begin, end);if(temp < right)exchange(begin, row + 1, column, row , column);else if(temp >= right){temp_zhi =yidong(begin, end, temp, jishu+1, ji_shu, 0, row+1, column);if(temp_zhi == 1)return 1;exchange(begin, row + 1, column, row , column);}}if(column < num-1 && biaoji != 3){exchange(begin, row, column + 1, row , column); //将0与其右边的元素交换存储位置temp = judge(begin, end);if(temp < right)exchange(begin, row, column + 1, row , column);else if(temp >= right){temp_zhi = yidong(begin, end, temp, jishu+1, ji_shu, 1, row, column+1);if(temp_zhi == 1)return 1;exchange(begin, row, column + 1, row , column);}}return 0; //移动失败，返回0}/*有用户输入待调整的数码矩阵最初状态的数，并将其存入到begin[][]数组中*/void shuru(int begin[][num],int blank[]){int temp, node, zero = 0;for (int i = 0; i < num; i++)for(int j = 0; j < num; j++){node = 1;printf("请输入第%d行，第%d列的元素的值：", i+1, j+1);scanf("%d", &temp);for (int q = 0; q <= i && node == 1; q++) //当输入的值有重复的，提示重新输入for (int w = 0; w < j; w++)if(temp == begin[q][w]){printf("输入重复，请重新输入\n");node = 0;j--;break;}if(temp < 0 || temp > num*num-1) //当输入的值不是在数码的区间范围内时，提示重新输入{printf("请输入从%d到%d的数\n", zero, num*num-1);node = 0;j--;}if(node == 1) //如果输入满足条件{if(temp == 0) //如果输入的值为零，由blank[0]记录行号，blank[1]记录列号{blank[0] = i;blank[1] = j;}begin[i][j] = temp;//将满足条件的值存储起来}}}int main(){int jishu = 0, ji_shu[50][3][3];//jishu存储已经遍历过的八数码图形的个数，jishu[][][]存储已经遍历过的八数码图形的形状int row; //存储数字零的行数int column; //存储数字零的列数int begin[num][num], blank[2],count=1;int end[num][num] = {1, 2, 3, 8, 0, 4, 7, 6, 5}; //给最终状态的数码矩阵赋值printf ("-------%d数码游戏开始！--------\n", num);shuru(begin, blank); //输入带调整状态的数码矩阵的值row = blank[0];column = blank[1];if(yidong (begin, end,judge(begin,end),jishu,ji_shu,4,row,column) == 0)printf("\n此8数码的问题可能无解！");elseshow(begin);getchar();getchar();return 0;}。