实验一 启发式搜索算法

启发式搜索实验讲解实验三搜索推理技术启发式搜索算法—A*算法1．实验目的（1）了解搜索推理的相关技术；（2）掌握启发式搜索算法或者基于规则推理的分析方法。

2．实验内容（2个实验内容可以选择1个实现）（1）启发式搜索算法。

熟悉和掌握启发式搜索的定义、估价函数和算法过程，并求解博弈问题，理解求解流程和搜索顺序；（2）产生式系统实验。

熟悉和掌握产生式系统的运行机制，掌握基于规则推理的基本方法。

3．实验报告要求（1）简述实验原理及方法，并请给出程序设计流程图。

（A-Star)算法是一种静态路网中求解最短路最有效的直接搜索方法。

公式表示为：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)等于最短距离，那么搜索将严格沿着最短路径进行，此时的搜索效率是最高的。

然后我们通过图文结合的形式来解释下，如下图：图中有这么几个要点先需要了解：1、类似迷宫图，分开始节点(start)、障碍物、结束节点(end)，我们需要从start节点探寻一条到end节点的路线2、对于探寻的每一步，都会以当前节点为基点，扫描其相邻的八个节点3、计算当前节点与start节点及到end的距离4、计算出最短路径如果明白了上面的场景描述，下面就可以进行分析了。

在A*算法中，核心思想是一个公式，上面已经提到过：f(n)=g(n)+h(n) （2）源程序清单：package com.itxxz.ui.suanfa.astar;import java.util.Iterator;import java.util.LinkedList;import java.util.Queue;import com.itxxz.ui.suanfa.astar.Point;public class ItxxzAstar {// 开始节点private Point startPoint = null;// 当前节点private Point endPoint = null;// 结束节点private Point currentPoint = null;// 最短距离坐标节点private Point shortestFPoint = null;// 迷宫数组地图private static final int[][] mazeArray = {{ 1, 0, 0, 0, 0 },{ 1, 0, 2, 0, 0 },{ 1, 0, 0, 0, 1 },{ 1, 0, 0, 0, 0 },{ 1, 1, 1, 1, 0 },{ 1, 0, 0, 0, 0 },{ 3, 0, 1, 1, 1 } };// 迷宫坐标对象private Point[][] mazePoint = null;// 开启队列，用于存放待处理的节点Queue openQueue = null;// 关闭队列，用于存放已经处理过的节点Queue closedQueue = null;// 起始节点到某个节点的距离int[][] FList = null;// 某个节点到目的节点的距离int[][] GList = null;// 起始节点经过某个节点到目的节点的距离int[][] HList = null; /*** 构造函数** @param maze* 迷宫图* @param startPoint* 起始节点* @param endPoint* 结束节点*/public ItxxzAstar(Point[][] mazePoint, Point startPoint, Point endPoint) { this.mazePoint = mazePoint;this.startPoint = startPoint;this.endPoint = endPoint;openQueue = new LinkedList();openQueue.offer(startPoint);closedQueue = new LinkedList();FList = new int[mazePoint.length][mazePoint[0].length];GList = new int[mazePoint.length][mazePoint[0].length];HList = new int[mazePoint.length][mazePoint[0].length];for (int i = 0; i < mazePoint.length; i++) {for (int j = 0; j < mazePoint[0].length; j++) {FList[i][j] = Integer.MAX_V ALUE;GList[i][j] = Integer.MAX_V ALUE;HList[i][j] = Integer.MAX_V ALUE;}}// 起始节点到当前节点的距离GList[startPoint.getX()][startPoint.getY()] = 0;// 当前节点到目的节点的距离HList[startPoint.getX()][startPoint.getY()] = getPointDistance(startPoint.getX(), startPoint.getY(), endPoint.getX(),endPoint.getY());// f(x) = g(x) + h(x)FList[startPoint.getX()][startPoint.getY()] = GList[startPoint.getX()][startPoint .getY()] + HList[startPoint.getX()][startPoint.getY()];}/*** 计算当前坐标与结束坐标之间的距离** 计算方法为每向相信坐标移动一次算作一个距离单位**/private int getPointDistance(int current_x, int current_y, int end_x,int end_y) {return Math.abs(current_x - end_x) + Math.abs(current_y - end_y);}/*** 数组迷宫地图** 0、可通行1、障碍2、开始节点3、结束节点**/public static void main(String[] args) {// 创建节点迷宫图Point[][] mazePoint = new Point[mazeArray.length][mazeArray[0].length];for (int i = 0; i < mazePoint.length; i++) {for (int j = 0; j < mazePoint[0].length; j++) {mazePoint[i][j] = new Point(i, j, mazeArray[i][j]);}}Point start = mazePoint[1][2];Point end = mazePoint[6][0];ItxxzAstar star = new ItxxzAstar(mazePoint, start, end);star.start();System.out.println(mazeArray.length + "," + mazeArray[0].length);star.printPath();}/*** 开始迷宫搜索**/public void start() {while ((currentPoint = findShortestFPoint()) != null) {if (currentPoint.getX() == endPoint.getX()&& currentPoint.getY() == endPoint.getY())return;updateNeighborPoints(currentPoint);}}/*** 获取距离最短的坐标点**/public Point findShortestFPoint() {currentPoint = null;shortestFPoint = null;int shortestFValue = Integer.MAX_V ALUE;Iterator it = openQueue.iterator();while (it.hasNext()) {currentPoint = it.next();if (FList[currentPoint.getX()][currentPoint.getY()] <= shortestFValue) { shortestFPoint = currentPoint;shortestFValue = FList[currentPoint.getX()][currentPoint.getY()];}}if (shortestFValue != Integer.MAX_V ALUE) {System.out.println("【移除节点】:" + shortestFPoint.getValue() + "["+ shortestFPoint.getX() + ","+ shortestFPoint.getY() + "]");openQueue.remove(shortestFPoint);closedQueue.offer(shortestFPoint);}return shortestFPoint;}/*** 更新临近节点*/private void updateNeighborPoints(Point currentPoint) {int current_x = currentPoint.getX();int current_y = currentPoint.getY();System.out.println("当前节点：[" + current_x + "," + current_y + "]");// 上if (checkPosValid(current_x - 1, current_y)) {System.out.print("上");updatePoint(mazePoint[current_x][current_y],mazePoint[current_x - 1][current_y]);}// 下if (checkPosValid(current_x + 1, current_y)) { System.out.print("下");updatePoint(mazePoint[current_x][current_y], mazePoint[current_x + 1][current_y]);}// 左if (checkPosValid(current_x, current_y - 1)) { System.out.print("左");updatePoint(mazePoint[current_x][current_y], mazePoint[current_x][current_y - 1]);}// 右if (checkPosValid(current_x, current_y + 1)) { System.out.print("右");updatePoint(mazePoint[current_x][current_y], mazePoint[current_x][current_y + 1]);}System.out.println("---------------");}/*** 检查该节点是否有效**/private boolean checkPosValid(int x, int y) { // 检查x,y是否越界，并且当前节点不是墙if ((x >= 0 && x < mazePoint.length)&& (y >= 0 && y < mazePoint[0].length)&& (mazePoint[x][y].getValue() != 1)) {// 检查当前节点是否已在关闭队列中，若存在，则返回"false"Iterator it = closedQueue.iterator();Point point = null;while (it.hasNext()) {if ((point = it.next()) != null) {if (point.getX() == x && point.getY() == y)return false;}}return true;}return false;}/*** 更新当前节点*/private void updatePoint(Point lastPoint, Point currentPoint) {int last_x = lastPoint.getX();int last_y = lastPoint.getY();int current_x = currentPoint.getX();int current_y = currentPoint.getY();// 起始节点到当前节点的距离int temp_g = GList[last_x][last_y] + 1;// 当前节点到目的位置的距离System.out.print(" [" + current_x + "," + current_y + "]"+ mazePoint[current_x][current_y].getValue());int temp_h = getPointDistance(current_x, current_y, endPoint.getX(),endPoint.getY());System.out.println("到目的位置的距离:" + temp_h);// f(x) = g(x) + h(x)int temp_f = temp_g + temp_h;System.out.println("f(x) = g(x) + h(x) :" + temp_f + "=" + temp_g + "+"+ temp_h);// 如果当前节点在开启列表中不存在，则：置入开启列表，并且“设置”// 1) 起始节点到当前节点距离// 2) 当前节点到目的节点的距离// 3) 起始节点到目的节点距离if (!openQueue.contains(currentPoint)) {openQueue.offer(currentPoint);currentPoint.setFather(lastPoint);System.out.println("添加到开启列表:" + currentPoint.getValue() + "["+ currentPoint.getX() + "," + currentPoint.getY() + "]");// 起始节点到当前节点的距离GList[current_x][current_y] = temp_g;// 当前节点到目的节点的距离HList[current_x][current_y] = temp_h;// f(x) = g(x) + h(x)FList[current_x][current_y] = temp_f;} else {// 如果当前节点在开启列表中存在，并且，// 从起始节点、经过上一节点到当前节点、至目的地的距离< 上一次记录的从起始节点、到当前节点、至目的地的距离，// 则：“更新”// 1) 起始节点到当前节点距离// 2) 当前节点到目的节点的距离// 3) 起始节点到目的节点距离if (temp_f < FList[current_x][current_y]) {// 起始节点到当前节点的距离GList[current_x][current_y] = temp_g;// 当前节点到目的位置的距离HList[current_x][current_y] = temp_h;// f(x) = g(x) + h(x)FList[current_x][current_y] = temp_f;// 更新当前节点的父节点currentPoint.setFather(lastPoint);}System.out.println("currentPoint:" + currentPoint.getValue() + "["+ currentPoint.getX() + "," + currentPoint.getY() + "]");System.out.println("currentPoint.father:"+ currentPoint.getFather().getValue() + "["+ currentPoint.getFather().getX() + ","+ currentPoint.getFather().getY() + "]");}}/*** 打印行走路径**/public void printPath() {System.out.println("================ 开始打印行走路径【用8 表示】================");Point father_point = null;int[][] result = newint[mazeArray.length][mazeArray[0].length];for (int i = 0; i < mazeArray.length; i++) {for (int j = 0; j < mazeArray[0].length; j++) {result[i][j] = 0;}}int step = 0;father_point = mazePoint[endPoint.getX()][endPoint.getY()];while (father_point != null) {System.out.println("【father_point】" + father_point.getValue() + "["+ father_point.getX() + "," + father_point.getY() + "]");if (father_point.equals(startPoint))result[father_point.getX()][father_point.getY()] = 2;else if (father_point.equals(endPoint)) {result[father_point.getX()][father_point.getY()] = 3;step++;} else {result[father_point.getX()][father_point.getY()] = 8;step++;}father_point = father_point.getFather();}// 打印行走步数System.out.println("step is : " + step);for (int i = 0; i < mazeArray.length; i++) {for (int j = 0; j < mazeArray[0].length; j++) {System.out.print(result[i][j] + " ");}System.out.println();}}}（3）实验结果及分析。

启发式搜索算法心得体会启发式搜索算法是一种通过推测来指导搜索方向的方法，它根据问题的特点和先前的知识进行启发式的搜索，以找到问题的最优解。

在实际应用中，启发式搜索算法被广泛应用于解决各种问题，如求解迷宫、规划路径等。

通过学习和理解启发式搜索算法，我获得了以下几点体会。

首先，启发式搜索算法的核心是启发函数的设计。

启发函数用于评估搜索节点的优劣，以决定搜索的方向。

好的启发函数能够明确指导搜索过程，减少不必要的搜索节点，提高搜索的效率。

在设计启发函数时，我们需要考虑问题的特点和约束条件，合理选择启发函数的评估指标，并通过启发函数的计算方法来优化搜索过程。

其次，启发式搜索算法在问题求解中的表现受到启发函数的影响。

不同的启发函数会导致不同的搜索策略和结果。

因此，在实际应用中，我们需要根据问题的不同特点和求解要求，设计适合的启发函数。

例如，在解决迷宫问题时，可以根据迷宫的布局和目标位置，设计一种启发函数来估计当前节点到目标的距离，以此指导搜索前进的方向。

再次，启发式搜索算法是一种权衡准确性和效率的方法。

通常情况下，启发式搜索算法能够在较短的时间内找到较优解，但并不能保证找到问题的最优解。

这是因为启发式搜索算法通过启发函数进行估计，存在一定的不确定性。

因此，在实际应用中，我们需要根据问题的实际需求，平衡准确性和效率的关系，选择适合的搜索算法和启发函数。

最后，启发式搜索算法是一个不断迭代的过程。

通过不断优化启发函数和搜索策略，我们可以不断改进算法的性能和效果。

在实际应用中，我们可以通过实验和反馈来不断改进启发函数和搜索策略，以逐步提高算法的性能和效果。

此外，启发式搜索算法也可以与其他算法结合使用，形成更加强大和高效的问题求解方法。

总之，通过学习和理解启发式搜索算法，我认识到它在问题求解中的重要性和广泛应用。

通过合理设计启发函数，我们能够明确指导搜索过程，提高搜索效率。

然而，启发式搜索算法也存在一定的局限性，需要在准确性和效率之间进行权衡。

启发式搜索——初识A*算法A*在游戏中有它很典型的用法，是人工智能在游戏中的代表。

A*算法在人工智能中是一种典型的启发式搜索算法，为了说清楚A*算法，先说说何谓启发式算法。

一、何谓启发式搜索算法在说它之前先提提状态空间搜索。

状态空间搜索，如果按专业点的说法，就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。

通俗点说，就是在解一个问题时，找到一个解题的过程，应用这个过程可以从求解的开始得到问题的结果。

由于求解问题的过程中分支有很多，主要是求解过程中求解条件的不确定性、不完备性造成的，使得求解的路径很多，这样就构成了一个图，我们说这个图就是状态空间。

问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。

这个寻找的过程就是状态空间搜索。

常用的状态空间搜索有深度优先和广度优先。

广度优先是从初始状态一层一层向下找，直到找到目标为止。

深度优先是按照一定的顺序，先查找完一个分支，再查找另一个分支，直至找到目标为止。

这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。

前面说的广度和深度优先搜索有一个很大的缺陷就是：他们都是在一个给定的状态空间中穷举。

这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不可预测的情况下就不可取了。

他们的效率实在太低，甚至不可完成。

在这里就要用到启发式搜索了。

启发式搜索就是在状态空间中搜索时，对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直至找到目标。

这样可以省略大量无谓的搜索路径，提高了效率。

在启发式搜索中，对位置的估价是十分重要的。

采用了不同的估价可以有不同的效果。

我们先看看估价是如何表示的。

启发中的估价是用估价函数表示的，如：f(n) = g(n) + h(n)其中f(n)是节点n的估价函数，g(n)是在状态空间中从初始节点到n节点的实际代价，h(n)是从n节点到目标节点最佳路径的估计代价。

在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。

启发式算法详细讲解
启发式算法（Heuristic Algorithm）也被称为启发算法或者近似算法，是一种通过启发式搜索的方式来解决问题的算法。

启发式算法与精确算法不同，它不保证最优解，但通常能够在合理的时间内找到较好的解。

启发式算法的基本思想是根据问题的特性和经验，使用一些启发式的规则或策略来指导搜索过程，以此来引导算法在搜索空间中找到可能更接近最优解的解。

具体来说，启发式算法通常包含以下步骤：
1. 初始解生成：通过某种方法生成一个初始解，可以是随机生成、基于经验的启发式规则生成等。

2. 邻域搜索：在当前解的周围搜索邻域解，通过一系列的局部搜索操作，如交换、插入、删除等，来生成新的解。

3. 评估函数：对新生成的解进行评估，评估函数用来衡量解的好坏程度，可以是目标函数值、代价函数值、质量评估值等。

4. 更新解：根据评估函数的结果，更新当前解为评估值更好的解。

5. 终止条件：根据预设的终止条件，判断是否终止搜索过程。

终止条件可以是找到满足要求的解或达到最大迭代次数等。

启发式算法的性能依赖于初始解的生成和邻域搜索操作的设计，以及评估函数的准确性。

在实际应用中，针对不同的问题，可以使用不同的启发式算法。

常见的启发式算法有贪婪算法、模拟退火算法、遗传算法、禁忌搜索等。

需要注意的是，启发式算法不能保证找到全局最优解，但可以在合理的时间内找到接近最优解的解。

启发式算法常常应用于那些NP难问题或解空间很大的问题中，可以在较短的时间内找到近似最优解，是一种非常实用的算法设计思想。

启发式搜索——初识A*算法A*在游戏中有它很典型的用法，是人工智能在游戏中的代表。

A*算法在人工智能中是一种典型的启发式搜索算法，为了说清楚A*算法，先说说何谓启发式算法。

一、何谓启发式搜索算法在说它之前先提提状态空间搜索。

状态空间搜索，如果按专业点的说法，就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。

通俗点说，就是在解一个问题时，找到一个解题的过程，应用这个过程可以从求解的开始得到问题的结果。

由于求解问题的过程中分支有很多，主要是求解过程中求解条件的不确定性、不完备性造成的，使得求解的路径很多，这样就构成了一个图，我们说这个图就是状态空间。

问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。

这个寻找的过程就是状态空间搜索。

常用的状态空间搜索有深度优先和广度优先。

广度优先是从初始状态一层一层向下找，直到找到目标为止。

深度优先是按照一定的顺序，先查找完一个分支，再查找另一个分支，直至找到目标为止。

这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。

前面说的广度和深度优先搜索有一个很大的缺陷就是：他们都是在一个给定的状态空间中穷举。

这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不可预测的情况下就不可取了。

他们的效率实在太低，甚至不可完成。

在这里就要用到启发式搜索了。

启发式搜索就是在状态空间中搜索时，对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直至找到目标。

这样可以省略大量无谓的搜索路径，提高了效率。

在启发式搜索中，对位置的估价是十分重要的。

采用了不同的估价可以有不同的效果。

我们先看看估价是如何表示的。

启发中的估价是用估价函数表示的，如：f(n) = g(n) + h(n)其中f(n)是节点n的估价函数，g(n)是在状态空间中从初始节点到n节点的实际代价，h(n)是从n节点到目标节点最佳路径的估计代价。

在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。

最优路径问题的启发式搜索算法启发式搜索算法是一种常用的优化算法，广泛应用于求解最优路径问题。

最优路径问题是指在给定的图中，寻找两个节点之间的最短路径或最优路径。

启发式搜索算法通过引入启发函数，对搜索过程进行优化，以提高搜索效率。

一、问题描述最优路径问题可以用图表示，图由节点和边组成。

节点表示位置或状态，边表示两个节点之间的关系或连接。

给定一个起始节点和目标节点，最优路径问题的目标是找到从起始节点到目标节点的最短路径或最优路径。

二、传统的搜索算法传统的搜索算法包括深度优先搜索（DFS）和广度优先搜索（BFS）。

DFS从起始节点开始，沿着每条可能的路径一直搜索到目标节点或无法继续搜索为止。

BFS则按层次遍历的方式，先搜索起始节点所有邻接节点，然后依次搜索这些邻接节点的邻接节点，直到找到目标节点。

传统的搜索算法存在效率低下的问题。

DFS通常能够找到一条路径，但该路径未必是最短路径或最优路径。

而BFS虽然能够找到最短路径，但在搜索过程中需要存储和遍历大量的节点，导致计算成本高。

三、启发式搜索算法启发式搜索算法引入了启发函数，用于评估搜索过程中每个节点的价值或成本。

启发函数通常根据问题的特定性质和经验进行设计，可以根据启发函数的值对节点进行评估和排序。

基于启发函数的评估，启发式搜索算法能够优先考虑具有更高潜在价值的节点，提高搜索效率。

最著名的启发式搜索算法之一是A*算法。

A*算法综合考虑了两个因素：从起始节点到当前节点的实际路径成本（表示为g值），以及从当前节点到目标节点的预估路径成本（表示为h值）。

A*算法通过计算启发函数值f = g + h，来评估节点的价值，从而选择具有最小f值的节点进行搜索。

A*算法在搜索过程中通过维护一个优先队列，不断扩展距离起始节点较好的节点，直到找到目标节点或搜索完成。

四、应用实例启发式搜索算法在许多领域都有应用，其中最著名的例子之一就是在计算机游戏中的路径规划。

在游戏中，启发式搜索算法能够帮助角色或NPC找到最短路径或最优路径，以避开障碍物或敌人。

实验一：搜索策略实验一、实验目的1、熟悉和掌握启发式搜索的定义、估价函数和算法过程。

2、利用A*算法求解N数码难题，理解求解流程和搜索顺序。

二、实验内容以八数码为例实现A或A*算法。

1、分析算法中的OPEN表CLOSE表的生成过程。

2、分析估价函数对搜索算法的影响。

3、分析启发式搜索算法的特点。

起始棋局目标棋局启发式函数选取为：f*(n)=g*(n)+h*(n)其中：g*(n)是搜索树中节点n的深度；h*(n)用来计算对应于节点n的数据中错放的棋子个数。

三、实验设计与结果八数码问题是个典型的状态图搜索问题。

搜索方式有两种基本的方式，即树式搜索和线式搜索。

搜索策略大体有盲目搜索和启发式搜索两大类。

盲目搜索就是无“向导”的搜索，启发式搜索就是有“向导”的搜索。

由八数码问题的部分状态图可以看出，从初始节点开始，在通向目标节点的路径上，各节点的数码格局同目标节点相比较，其数码不同的位置个数在逐渐减少，最后为零。

所以，这个数码不同的位置个数便是标志一个节点到目标节点距离远近的一个启发性信息，利用这个信息就可以指导搜索。

即可以利用启发信息来扩展节点的选择，减少搜索范围，提高搜索速度。

由此解决八数码问题就是在初始状态和目标状态两个状态之间寻找一系列可过渡状态。

利用A*算法实现寻找中间状态，从而得到目标状态。

根据启发式搜索算法A*算法的具体步骤，结合八数码问题的要求，从而得出相应的流程图为：其中：OPEN表：算法已搜索但尚未扩展的节点集合。

CLOSED表：算法已扩展的节点集合。

实验输出结果：运行程序，输入起始棋局与目标棋局：结果输出为：四、程序1、设定启发式函数：八数码问题的目标是要搜索到目标节点，所以为了尽快的向目标节点进行靠近，可以把启发式函数设定为当前节点与目标节点中状态的差异，即与目标节点中数码的位置不同的个数作为启发函数的返回值，然后根据启发函数值找出启发值最小的状态节点进行扩展。

2、OPEN表和CLOSE表的生成过程：OPEN表是用来存放经过扩展得到的待考察的状态节点，CLOSE表是用来存放考察过的状态节点，并且标记上当前节点的编号和父节点的编号，然后可以根据编号便可以形成一个搜索树，即可以找到一个解路径。

人工智能基础实验报告实验名称：八数码问题姓名：张俊学号：2220092333指导老师：邓安生启发式搜索算法1. 实验内容：使用启发式搜索算法求解8数码问题。

⑴ 编制程序实现求解8数码问题A *算法，采用估价函数()()()()w n f n d n p n ⎧⎪=+⎨⎪⎩， 其中：()d n 是搜索树中结点n 的深度；()w n 为结点n 的数据库中错放的棋子个数；()p n 为结点n 的数据库中每个棋子与其目标位置之间的距离总和。

⑵ 分析上述⑴中两种估价函数求解8数码问题的效率差别，给出一个是()p n 的上界的()h n 的定义，并测试使用该估价函数是否使算法失去可采纳性。

2. 实验目的熟练掌握启发式搜索A *算法及其可采纳性。

3. 实验原理八数码问题是在3行和3列构成的九宫棋盘上放置数码为1到8的8个棋盘，剩下一个空格的移动来不断改变棋盘的布局，求解这类问题的方法是：给定初始布局（即初始状态）和目标布局（即目标状态），定义操作算子的直观方法是为每个棋牌制定一套可能的走步》上，下，左，右四种移动，再根据所定义的启发式搜索函数在搜索过程中选择最合适的操作算子，得到最优的路径。

4.源代码#include <iomanip>#include <stdlib.h>#include <time.h>#include <iostream>#include <stdio.h>#include <conio.h>#include <math.h>//以上为C++源文件using namespace std;static int space=0;int target[9];class EightNum//定义一个EightNum 类{public:int num[9];int f;//初始状态与目标状态相比，棋子错放个数int deap;//深度int evalfun;//状态的估价值EightNum *parent;//以下为类内成员函数的声明EightNum(int nnum[9]);int get_evalfun();int get_deapfun();void eval_func(int id);int Canspread(int n);void Spreadchild(int n);void getnum(int num1[9]);void setnum(int num1[9]);void show(void);int operator ==(EightNum& NewEightN);int operator ==(int num2[9]);int Shownum();};//-----------------------以下为EightNum类成员函数定义-----------------// class Stack{private:EightNum * eightnum;public:Stack * next;EightNum * Minf();EightNum * Belong(EightNum * suc);void Putinto(EightNum * suc);};EightNum::EightNum(int nnum[9]){//此函数功能为：初始化num[]；for(int i=0;i<9;i++)num[i]=nnum[i];f=0;deap=0;parent=NULL;}int EightNum::get_evalfun(){return evalfun;}int EightNum::get_deapfun(){return deap;}void EightNum::eval_func(int id){//此函数为估价函数int i,qifa;qifa=0;switch(id){case 1:{for(i=0;i<9;i++){if(num[i]!=target[i])qifa++;}break;}case 2:{int j, h1,h2;for(i=0;i<9;i++){for(j=0;j<9;j++){if(num[j]==i)h1=j;if(target[j]==i)h2=j;}qifa+=(int)(fabs((double)(h1/3 - h2/3)) + fabs((double)(h1%3 - h2%3)));}break;}case 3:{int j, h1,h2;for(i=0;i<9;i++){for(j=0;j<9;j++){if(num[j]==i)h1=j;if(target[j]==i)h2=j;}qifa+=(int)(fabs((double)(h1/3 - h2/3)) + fabs((double)(h1%3 - h2%3)));}qifa=3*qifa;break;}default :break;}f=qifa;if(this->parent==NULL) deap=0;else deap=this->parent->deap+1;evalfun=deap+f;}int EightNum::Canspread(int n){//判断空格"0"可否移动int i,flag = 0;for(i = 0;i < 9;i++)if(this->num[i] == 0)break;switch(n){case 1:if(i/3 != 0)flag = 1;break;case 2:if(i/3 != 2)flag = 1;break;case 3:if(i%3 != 0)flag = 1;break;case 4:if(i%3 != 2)flag = 1;break;default:break;}return flag ;}void EightNum::Spreadchild(int n){//扩展child节点的子节点int i,loc,qifa;for(i = 0;i < 9;i++)this->num[i] = this->parent->num[i];for(i = 0;i < 9;i++)if(this->num[i] == 0)break;if(n==0)loc = i%3+(i/3 - 1)*3;else if(n==1)loc = i%3+(i/3 + 1)*3;else if(n==2)loc = i%3-1+(i/3)*3;elseloc = i%3+1+(i/3)*3;qifa = this->num[loc];this->num[i] = qifa;this->num[loc] = 0;}void EightNum::getnum(int num1[9]){ for(int i=0;i<9;i++)num1[i]=num[i];}void EightNum::setnum(int num1[9]){ for(int i=0;i<9;i++)num[i]=num1[i];}void EightNum::show(){//输出函数for(int i=0;i<9;i++){cout<<num[i]<<" ";if((i+1)%3==0)cout<<"\n";}cout<<"--------------------";}int EightNum::Shownum(){if(this == NULL)return 0;else{int n = this->parent->Shownum();this->show();cout<<endl;return n+1;}}int EightNum::operator ==(EightNum& NewEightN){int compere=1;for(int i=0;i<9;i++)if(num[i]!=NewEightN.num[i]){compere=0;break;}if(compere==0) return 0;else return 1;}//-----------------------以下为分函数的定义---------------------////判断是否有解的函数int solve(int num[9],int target[9]){int i,j;int num_con=0,tar_con=0;for(i=0;i<9;i++)for(j=0;j<i;j++){if(num[j]<num[i] && num[j]!=0)num_con++;if(target[j]<target[i] && target[j]!=0)tar_con++;}num_con=num_con%2;tar_con=tar_con%2;if((num_con==0 && tar_con==0)||(num_con==1 && tar_con==1))return 1;elsereturn 0;}EightNum * Stack::Minf(){Stack * qifa =this->next;Stack * min = this->next;Stack * minp = this;EightNum * minx;while(qifa->next != NULL){if((qifa->next->eightnum->get_evalfun()) < (min->eightnum->get_evalfun())){min = qifa->next;minp = qifa;}qifa = qifa->next;}minx = min->eightnum;qifa = minp->next;minp->next = minp->next->next;free(qifa);return minx;}//判断节点是否属于OPEN表或CLOSED表EightNum * Stack::Belong(EightNum * suc){Stack * qifa = this-> next ;if(qifa == NULL)return NULL;while(qifa != NULL){if(suc==qifa->eightnum)return qifa ->eightnum;qifa = qifa->next;}return NULL;}//把节点存入OPEN 或CLOSED 表中void Stack::Putinto(EightNum * suc){Stack * qifa;qifa =(Stack *) malloc(sizeof(Stack));qifa->eightnum = suc;qifa->next = this->next;this->next = qifa;}int BelongProgram(EightNum * suc ,Stack *Open ,Stack *Closed ,EightNum goal,int m ){EightNum * qifa = NULL;int flag = 0;if((Open->Belong(suc) != NULL) || (Closed->Belong(suc) != NULL)){if(Open->Belong(suc) != NULL) qifa = Open->Belong(suc);else qifa = Closed->Belong(suc);flag=1;}else{Open->Putinto(suc);suc->eval_func(m);}return flag;}//扩展后继节点总函数void Spread(EightNum * suc, Stack * Open, Stack * Closed, EightNum goal,int m){int i;EightNum * child;for(i = 0; i < 4; i++){if(suc->Canspread(i+1)){space++;child = (EightNum *) malloc(sizeof(EightNum));child->parent = suc;child->Spreadchild(i);child->eval_func(m);if(BelongProgram(child, Open, Closed, goal,m)) //判断子节点是否属于OPEN或CLOSED表free(child);}}}//执行函数EightNum * Process(EightNum * org, EightNum goal, Stack * Open, Stack * Closed,int m){while(1){if(Open->next == NULL)return NULL;EightNum * minf =Open->Minf();Closed->Putinto(minf);if((*minf)==goal)return minf;Spread(minf, Open, Closed, goal,m);}}//------------------------A*算法搜索函数----------------------//void A(int id,EightNum start,EightNum Target){EightNum * result;space=0;float time;Stack *Open = (Stack *) malloc(sizeof(Stack));Open->next = NULL;Stack *Closed = (Stack *) malloc(sizeof(Stack));Closed->next = NULL;clock_t startt,finisht;startt=clock();//开始时间start.eval_func(id);Open->Putinto(&start);result = Process(&start, Target, Open, Closed,id); //进行剩余的操作cout<<"\n搜索过程:\n"<<result->Shownum()<<endl;finisht=clock();time=(float)(finisht-startt);cout<<endl<<id<<"算法处理结果：所耗时间:";cout<<time;cout<<"ms, ";cout<<"所耗空间:";cout<<space;cout<<"块, "<<endl<<endl;}//-----------------------------主函数-----------------------------//int main(void)//主函数{int i,j;int flag;int num[9];int error;do{error=0;cout<<"请输入八数码问题的初始状态(0代表空格,“棋子”间用空格隔开):"<<endl;for(i=0;i<9;i++){flag=0;cin>>num[i];for(j=0;j<i;j++)if(num[j]==num[i])flag=1;if(num[i]<0||num[i]>8||flag==1){error++;}}if(error!=0)cout<<"输入数据错误!请重新输入!"<<endl;}while(error!=0);//输入八数码问题的初始状态(0代表空格,“棋子”间用空格隔开）；int error1;do{error1=0;cout<<"请输入新的目标状态(用0代表空格,“棋子”间用空格隔开):"<<endl;for(i=0;i<9;i++){flag=0;cin>>target[i];for(j=0;j<i;j++)if(target[j]==target[i])flag=1;if(target[i]<0||target[i]>9||flag==1){error1++;}}if(error1!=0)cout<<"输入数据错误!请重新输入!"<<endl;}while(error1!=0);//输入八数码问题的目标状态(用0代表空格,中间用空格隔开）；EightNum start(num),Target(target);int m=solve(num,target);//判断初始状态到目标状态是否有解，有解返回1，误解返回0；if(m==0){cout<<"此状态无解!"<<endl;return 0;}int id=0;while(id!=3){cout<<"1. 错放的棋子个数为;\n2.每个棋子与目标位置之间的距离总和为;"<<endl;cout<<"3.结束，退出程序！"<<endl;cout<<"\n请选择功能,分别输入“1”“2”“3”进行选择："<<endl;cin>>id;switch(id){case 1:{cout<<"错放的棋子个数结果为:\n(以下逐一展示搜索过程：)"<<endl;A(1,start,Target);break;}case 2:{cout<<"每个棋子与其目标位置之间的距离总和为:\n(以下逐一展示搜索过程：)"<<endl;A(2,start,Target);break;}default: break;}}cout<<"啊啊….程序结束!!";}实验截图实验中遇到的问题1：开始程序只能运行一种方式即按照错位个数搜索，后经过查找相关资料，修改后可程序可进行选择，两种方法结合在一起根据选择运行。

启发式算法简介启发式算法（Heuristic Algorithm）是一种通过寻找经验法则或启发式知识来解决复杂问题的算法。

启发式算法在面对NP-难问题时具有较高的效率和实用性，但不能保证获得最优解。

这种算法通常通过探索问题的解空间来找到近似最优解，是一种具有全局搜索特性的方法。

启发式算法的设计灵感来源于人类的思维方式。

通过运用特定的规则和策略，启发式算法可以快速找到问题的解，尽管该解不一定是最优解。

启发式算法的优势在于其高效性和实用性，特别适用于实际应用中的大规模、复杂问题的求解。

常见启发式算法1. 蚁群算法（Ant Colony Optimization，ACO）蚁群算法模拟了现实生活中蚂蚁寻找食物的行为，它通过蚂蚁在解空间中的移动来搜索最优解。

蚁群算法的关键是利用信息素的概念，即蚂蚁在探索过程中通过释放和感知信息素来进行交流。

信息素的释放和感知会影响蚂蚁的移动策略，从而实现解空间中的全局搜索。

2. 遗传算法（Genetic Algorithm，GA）遗传算法是一种模拟自然界中生物进化过程的优化算法。

它通过模拟遗传学中的基因、染色体和群体等概念，通过遗传、交叉和变异等操作来搜索最优解。

遗传算法通过选择和保留优良个体，逐代进行进化，最终得到接近最优解的结果。

3. 粒子群优化算法（Particle Swarm Optimization，PSO）粒子群优化算法模拟了鸟群或鱼群中个体之间的合作和协调行为。

在粒子群算法中，每个个体被称为粒子，每个粒子在解空间中通过自身的经验和邻居粒子的协作来搜索最优解。

粒子群算法通过粒子的位置和速度的调整逐步逼近最优解。

4. 模拟退火算法（Simulated Annealing，SA）模拟退火算法模拟了固体退火的过程，在搜索解空间中自适应地调整温度来避免陷入局部最优解。

在模拟退火算法中，初始温度较高时，算法具有较大的搜索范围，然后逐渐降低温度，减少搜索范围，最终收敛到全局最优解。

最短路问题的启发式搜索算法最短路问题是指在带权重的有向图或无向图中，寻找从一个顶点到另一个顶点的最短路径。

启发式搜索算法是一种利用启发信息来指导搜索的方法。

本文将介绍两种常用的启发式搜索算法——Dijkstra算法和A*算法。

一、Dijkstra算法Dijkstra算法是一种经典的最短路算法，它适用于无负权边的有向图或无向图。

下面是Dijkstra算法的伪代码：1. 初始化距离数组dist，将起始顶点的距离初始化为0，其他顶点距离初始化为正无穷。

2. 创建一个空的优先队列Q，并将起始顶点入队。

3. 当队列不为空时，执行以下步骤：- 出队一个顶点u。

- 遍历u的所有邻接顶点v，如果从起始顶点到v的距离dist[u]加上u到v的边权重小于dist[v]，则更新dist[v]的值，将v入队。

4. 当队列为空时，算法结束。

Dijkstra算法的核心思想是通过不断更新起始顶点到其他顶点的距离值，直到找到最短路径。

该算法保证了每次从队列中取出的顶点都是到起始顶点距离最短的顶点，因此可以得到最短路径。

二、A*算法A*算法是一种常用的启发式搜索算法，它适用于带有启发信息的有向图或无向图。

下面是A*算法的伪代码：1. 初始化起始顶点的估计距离值为0。

2. 创建一个空的优先队列Q，并将起始顶点入队，估计距离值作为优先级。

3. 当队列不为空时，执行以下步骤：- 出队一个顶点u。

- 如果u是目标顶点，则算法结束。

- 遍历u的所有邻接顶点v，计算从起始顶点到v的实际距离和估计距离之和f.- 如果f小于v的估计距离值，则更新v的估计距离值为f，并将v入队。

4. 当队列为空时，算法结束。

A*算法的核心思想是通过启发式估计函数，将优先级队列中的顶点按照估计距离值进行排序。

其中，估计距离值等于实际距离值加上启发式函数给出的估计值。

通过这种方式，A*算法可以在保证搜索效率的同时，找到最短路径。

结语最短路问题的启发式搜索算法为解决最短路径提供了有效的方法。

实验报告姓名：***学号：**********班级：软件二班实验名称：启发式搜索课程名称：人工智能实验日期：2015.11.09实验环境：Visual C++实验目的以及内容：1、实验内容：使用启发式搜索算法求解八数码问题。

（1）编制程序实现求解八数码问题A*算法，采用估价函数其中：d(n)是搜索树中节点n的深度；w(n)为节点n的数据库中错放的棋子个数；p(n)为节点n的数据库中的每个棋子与其目标位置之间的距离的总和。

（2）分析上述（1）中的两种估价函数求解八数码问题的效率差别，给出一个是p(n)的上界的h(n)的定义，并测试使用该估价函数是否使算法失去可采纳性。

2、实验目的：熟练的掌握启发式搜索A*算法及其可采纳性。

3. 实验原理：八数码问题是在3行和3列构成的九宫棋盘上放置数码为1到8的8个棋盘，剩下一个空格的移动来不断改变棋盘的布局，求解这类问题的方法是：给定初始布局（即初始状态）和目标布局（即目标状态），定义操作算子的直观方法是为每个棋牌制定一套可能的走步》上，下，左，右四种移动，再根据所定义的启发式搜索函数在搜索过程中选择最合适的操作算子，得到最优的路径。

代码：#include"stdio.h"#define num 3void 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");}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;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){int temp_zhi;show(begin);if(jishu >= 20)return 0;int node;int temp;for(int q=0; q<jishu; q++){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){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)return 1;if(row > 0 && biaoji != 0){exchange(begin, row - 1, column, row , column);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);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);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);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;}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] = i;blank[1] = j;}begin[i][j] = temp;}}}int main(){int jishu = 0, ji_shu[50][3][3];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 ("-------8数码游戏开始！--------\n");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;}实验截图：实验总结：1、A*搜索算法：取g(n)=d(n)，h(n)=w(n)，其中w(n)表示以目标为基准，结点n的状态中每一个数码牌与其目标位置之间的距离（不考虑夹在其间的数码牌）的总和，由于从结点n转换成目标结点至少需要w(n)步，所以对任意n，恒有w(n) ≤h*(n)。

启发式搜索算法范文
启发式算法
一、概述
启发式算法是一种智能算法，它使用了一定的启发式信息来根据当前状态，推测要找到最优解的最有可能的选择，以找到问题的最优解。

这类算法不是把所有可能的情况都考虑进去，而是根据当前信息和历史信息推测出最有可能的解，从而缩小空间，加快速度。

二、启发式的原理
启发式算法的核心思想是：以其中一种形式编码给定问题，然后以其中一种方式状态空间，得到最优解。

状态空间表示可以到达的所有状态，通常用一棵树表示。

启发式算法利用一定的经验和知识来指导，并尽可能快速地得到所需要的答案。

常用算法有回溯法、遗传算法、模拟退火算法、启发式A*算法等。

其中，回溯法是一种暴力算法，主要用在状态空间树上；遗传算法是一种模拟生物进化学习的算法；模拟退火算法是一种模拟物理热力学的算法；启发式A*算法是一种基于启发式函数（Heuristicc Function）的算法。

三、启发式的应用
启发式算法具有许多应用，如地图路径查找、空间优化、赛车、基因算法、寻路、网络传输调度等。

启发式搜索实验报告2015-2016第1学期《人工智能基础》实验报告实验名称:启发式搜索算法专业班级学号姓名1、实验环境Visual C++ 6.02、实验目的和要求(复述问题)使用启发式算法求解8数码问题(1) 编制程序实现求解8数码问题A*算法，采用估价函数f(n)=d(n)+p(n)其中:d(n)是搜索树中结点n的深度;w(n)为节点n的数据库中错放的旗子个数;p(n)为结点n的数据库中每个棋子与其目标位置之间的距离总和。

(2) 分析上述(1)中两种估价函数求解8数码问题的效率差别，给出一个是p(n)的上界h(n)的定义，并测试该估价函数是否使算法失去可采纳性。

实验目的:熟练掌握启发式搜索A*算法及其可采纳性。

3、解题思路、代码3.1解题思路八数码问题的求解算法(1) 盲目搜索宽度优先搜索算法、深度优先搜索算法(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*算法针对八数码问题启发函数设计如下:F(n)=d(n)+p(n) (4)1 / 112015-2016第1学期《人工智能基础》实验报告其中A*算法中的g(n)根据具体情况设计为d(n)，意为n节点的深度，而h(n)设计为p(n)，意为放错的数码与正确的位置距离之和。

启发式搜索算法
一、定义
启发式，又称为有启发性，是一种智能算法，它通过有效地给定的空
间来求解其中一特定问题，从而找到一个最优解。

启发式算法是以概率机
器学习的概念为基础，通过利用已有知识结合启发式函数来实现有效的。

二、分类
启发式可以分为两类：有限空间和无限空间。

有限空间算法包括深度
优先（DFS）、广度优先（BFS）等，这些算法通过有限次数的步骤状态空间，来尝试找出最佳解决方案。

而无限空间算法则是基于空间的随机加载，并根据不断变化的环境状况，来更新策略，以达到更优的最终解决方案。

三、基本原理
启发式算法的主要思想是在不知道结果的情况下，通过评估当前状态
来估计未来状态的最优解。

因此，启发式算法需要引入一种启发式函数，
即评价函数，来评估当前状态，以更有效地空间并找出最优解。

四、算法步骤
1.设置初始状态：设置初始状态，即的起点，以决定从哪里开始。

2.评估函数：定义一个评估函数，该函数可以比较当前状态与最终状
态之间的差距。

《人工智能》实验报告专业计算机科学与技术年级大三姓名吕小春学号 0927401108指导老师实验室使用日期苏州大学计算机科学与技术学院统一印制二零零二年八月实验一启发式搜索一、实验目的：熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A算法求解九宫问题，理解求解流程和搜索顺序。

二、实验方法：1.先熟悉启发式搜索算法；2.用C、C++或JA V A 语言编程实现实验内容。

三、实验内容：问题描述：用启发式搜索方法求解下列九宫问题四、实验步骤（1）状态表示的数据结构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){}}（2）状态扩展规则的表示算法的功能：产生8数码问题的解(由初始状态到达目标状态的过程）输入：初始状态，目标状态输出：从初始状态到目标状态的一系列过程算法描述：Begin：读入初始状态和目标状态，并计算初始状态评价函数值f；根据初始状态和目标状态，判断问题是否可解；If(问题可解)把初始状态假如open表中；While（未找到解&&状态表非空）①在open表中找到评价值最小的节点，作为当前结点；②判断当前结点状态和目标状态是否一致，若一致，跳出循环；否则跳转到③；③对当前结点，分别按照上、下、左、右方向移动空格位置来扩展新的状态结点，并计算新扩展结点的评价值f并记录其父节点；④对于新扩展的状态结点，判断其是否重复，若不重复，把其加入到open表中；⑤把当前结点从open表中移除；End whileEnd if输出结果；End（3）搜索产生的状态空间图（4）OPEN表和CLOSE表变化过程1）把起始节点S放入OPEN表，计算估价函数f (s)2）如果OPEN表判断为空，则失败无解，否则则程序继续3）将OPEN表中估价函数f（s）最小的节点取出并放入CLOSE表中4）判断该节点是否为目标节点，是则搜索成功，结束程序，否则继续5)用拓展函数拓展该节点，得到其后继结点并算每一个后继结点的估价函数值，在算一下是否有后继结点与OPEN表和CLOSE表中的重复，再将后继结点放入OPEN表中并进行重新排序。