实验一 启发式搜索
启发式搜索实验讲解
启发式搜索实验讲解实验三搜索推理技术启发式搜索算法—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）实验结果及分析。
搜索(博弈树的启发式搜索)
14
一字棋棋盘
例如，对图1所示的棋局有估价函数值 e（P）＝6-4＝2 在搜索过程中，具有对称性的棋局认为是同一棋 局。例如，图2所示的棋局可以认为是同一个棋局， 这样可以大大减少搜索空间。图3给出了第一着走棋 以后生成的博弈树。图中叶节点下面的数字是该节点 的静态估值，非叶节点旁边的数字是计算出的倒推值。 从图中可以看出，对MAX来说S2是一着最好的走棋， 它具有较大的倒推值。
人下棋的思考方式
人下棋实际上采用一种试探性的方法: 假定走了一步棋,看对方会有哪些应法; 再根据对方的每一种应法,看我方是否有好的回应; 这一过程一直进行下去,直到若干步后,找到一个满意的走法 为止. 极大极小搜索方法模拟的就是人的这样一种思维过程.
节点A,轮到MAX下棋….
MAX
2.非叶子节点的估值由倒推取值的方法取得
博弈是一类富有智能行为的竞争活动，如下棋
、打牌、战争等。博弈可分为双人完备信息博 弈和机遇性博弈。所谓双人完备信息博弈，就 是两位选手对垒，轮流走步，每一方不仅知道 对方已经走过的棋步，而且还能估计出对方未 来的走步。对弈的结果是一方赢，另一方输； 或者双方和局。这类博弈的实例有象棋、围棋 等。所谓机遇性博弈，是指存在不可预测性的 博弈，例如掷币等。对机遇性博弈，由于不具 备完备信息，因此我们不作讨论。
算法框架 整个算法分为四个步骤： 1、以当前状态为根结点产生一个博弈树。 2、对博弈树的每一个叶结点，利用判定函数给出它的判定值。 3、从叶结点开始，一层一层地回溯。在回溯过程中，利用最大/最小判定为每一个结 点给出其判定值。 4、MAX方选择下一层中判定值最大的结点，作为它的下一状态。
启发式搜索——精选推荐
启发式搜索启发式搜索1. 相关概念在宽度优先和深度优先搜索⾥⾯，我们都是根据搜索的顺序依次进⾏搜索，可以称为盲⽬搜索，搜索效率⾮常低。
⽽启发式搜索则⼤⼤提⾼了搜索效率，由这两张图可以看出它们的差别：什么是启发式搜索（heuristic search）⽤当前与问题有关的信息作为启发式信息，这些信息是能够提升查找效率以及减少查找次数的。
我们定义了⼀个估价函数h(x)。
h(x)是对当前状态x的⼀个估计，表⽰x状态到⽬标状态的距离。
1. h(x) >= 0；2. h(x)越⼩表⽰x越接近⽬标状态；3. 如果h(x) ==0，说明达到⽬标状态。
有了启发式信息还不⾏，还需要起始状态到x状态所花的代价，我们称为g(x)。
g(x)就是我们实际要求解的问题。
⽐如在⾛迷宫问题、⼋数码问题，我们的g(x)就是从起点到 x位置花的步数，h(x)就是与⽬标状态的曼哈顿距离或者相差的数⽬；在最短路径中，我们的g(x)就是起点到x点的最短距离，h(x)就是x点到⽬标结点的最短路或直线距离。
令F(x)=g(x)+h(x)，作为我们的搜索依据。
当F(x) = g(x)的时候就是⼀个等代价搜索，完全是按照花了多少代价去搜索。
⽐如bfs，我们每次都是从离得近的层开始搜索，⼀层⼀层搜；以及dijkstra算法，也是依据每条边的代价开始选择搜索⽅向。
当F(x) = h(x)的时候就相当于⼀个贪婪优先搜索。
每次都是向最靠近⽬标的状态靠近。
⼈们发现，等代价搜索虽然具有完备性，能找到最优解，但是效率太低。
贪婪优先搜索不具有完备性，不⼀定能找到解，最坏的情况下类似于dfs。
这时候，有⼈提出了A算法。
令F(x) = g(x) + h(x)。
（这⾥的h(x)没有限制）。
虽然提⾼了算法效率，但是不能保证找到最优解，不适合的h(x)定义会导致算法找不到解。
不具有完备性和最优性。
⼏年后有⼈提出了A*算法。
该算法仅仅对A算法进⾏了⼩⼩的修改。
并证明了当估价函数满⾜⼀定条件，算法⼀定能找到最优解。
启发式搜索算法心得体会
启发式搜索算法心得体会启发式搜索算法是一种通过推测来指导搜索方向的方法，它根据问题的特点和先前的知识进行启发式的搜索，以找到问题的最优解。
在实际应用中，启发式搜索算法被广泛应用于解决各种问题，如求解迷宫、规划路径等。
通过学习和理解启发式搜索算法，我获得了以下几点体会。
首先，启发式搜索算法的核心是启发函数的设计。
启发函数用于评估搜索节点的优劣，以决定搜索的方向。
好的启发函数能够明确指导搜索过程，减少不必要的搜索节点，提高搜索的效率。
在设计启发函数时，我们需要考虑问题的特点和约束条件，合理选择启发函数的评估指标，并通过启发函数的计算方法来优化搜索过程。
其次，启发式搜索算法在问题求解中的表现受到启发函数的影响。
不同的启发函数会导致不同的搜索策略和结果。
因此，在实际应用中，我们需要根据问题的不同特点和求解要求，设计适合的启发函数。
例如，在解决迷宫问题时，可以根据迷宫的布局和目标位置，设计一种启发函数来估计当前节点到目标的距离，以此指导搜索前进的方向。
再次，启发式搜索算法是一种权衡准确性和效率的方法。
通常情况下，启发式搜索算法能够在较短的时间内找到较优解，但并不能保证找到问题的最优解。
这是因为启发式搜索算法通过启发函数进行估计，存在一定的不确定性。
因此，在实际应用中，我们需要根据问题的实际需求，平衡准确性和效率的关系，选择适合的搜索算法和启发函数。
最后，启发式搜索算法是一个不断迭代的过程。
通过不断优化启发函数和搜索策略，我们可以不断改进算法的性能和效果。
在实际应用中，我们可以通过实验和反馈来不断改进启发函数和搜索策略，以逐步提高算法的性能和效果。
此外，启发式搜索算法也可以与其他算法结合使用，形成更加强大和高效的问题求解方法。
总之，通过学习和理解启发式搜索算法，我认识到它在问题求解中的重要性和广泛应用。
通过合理设计启发函数，我们能够明确指导搜索过程，提高搜索效率。
然而，启发式搜索算法也存在一定的局限性，需要在准确性和效率之间进行权衡。
2014-人工智能应用技术实验报告-启发式搜索程序设计
实验报告课程名称人工智能应用技术实验项目启发式搜索程序设计实验仪器Windows/VisualStudio学院信息管理学院专业信息安全班级/学号信安1401/学生姓名Cony实验日期2016-5-17成绩指导教师赵刚北京信息科技大学信息管理学院（课程上机）实验报告5.实验过程：#include<stdio.h>#include<malloc.h>#include<assert.h>//#include "rand.h"#include<stdlib.h>#include<time.h>#define RANDINIT() srand(time(NULL))#define RANDOM() ((float)rand() / (float)RAND_MAX)#define RANDMAX(x) (int)((float)(x)*rand()/(RAND_MAX+1.0))#define MAX_BOARD9#define ALPHA(double)1.0 /* Depth Bias */#define BETA(double)2.0 /* Misplaced Tile Bias */#define MAX_DEPTH26struct board_s;typedef struct board_s {struct board_s *pred;double f;double g;double h;char array[MAX_BOARD];char blank;char depth;} board_t;/* Node Functions */board_t *nodeAlloc( void ){board_t *board_p;board_p = (board_t *)malloc( sizeof(board_t) );assert(board_p);board_p->pred = NULL;board_p->f = board_p->g = board_p->h = (double)0.0;return board_p;}void nodeFree( board_t *board_p ){assert(board_p);free(board_p);return;}/* List Functions */#define MAX_LIST_ELEMENTS100000typedef struct {int numElements;board_t *elements[MAX_LIST_ELEMENTS];} list_t;#define listCount(x) ((x)->numElements)list_t openList_p;list_t closedList_p;void initList( list_t *list_p ){int i;assert(list_p);list_p->numElements = 0;for (i = 0 ; i < MAX_LIST_ELEMENTS ; i++) { list_p->elements[i] = (board_t *)0;}return;}int onList( list_t *list_p, char *board_p, int *pos ) {int i, j;assert(list_p); assert(board_p);for (i = 0 ; i < MAX_LIST_ELEMENTS ; i++) {if (list_p->elements[i] != (board_t *)0) {for (j = 0 ; j < MAX_BOARD ; j++) {if (list_p->elements[i]->array[j] != board_p[j]) break; }if (j == MAX_BOARD) {if (pos) *pos = i;return 1;}}}return 0;}board_t *getListBest( list_t *list_p ){int i, first=1;int best=-1;double best_f;board_t *board_p;for (i = 0 ; i < MAX_LIST_ELEMENTS ; i++) {if (list_p->elements[i]) {if (first) {best = i;best_f = list_p->elements[best]->f;first = 0;} else {if (list_p->elements[i]->f < best_f) {best = i;best_f = list_p->elements[best]->f;}}}}assert( best != -1 );board_p = list_p->elements[best];list_p->elements[best] = (board_t *)0;list_p->numElements--;return board_p;}board_t *getList( list_t *list_p, char *board_p ) {int pos, ret;board_t *retboard_p = (board_t *)0;assert(list_p); assert(board_p);ret = onList( list_p, board_p, &pos );if (ret) {retboard_p = list_p->elements[pos];list_p->elements[pos] = (board_t *)0;list_p->numElements--;}return retboard_p;}void putList( list_t *list_p, board_t *board_p ) {int i;assert(list_p); assert(board_p);for (i = 0 ; i < MAX_LIST_ELEMENTS ; i++) {if (list_p->elements[i] == (board_t *)0) {list_p->elements[i] = board_p;list_p->numElements++;return;}}assert(0);}void cleanupList( list_t *list_p ){int i;assert(list_p);for (i = 0 ; i < MAX_LIST_ELEMENTS ; i++) {if (list_p->elements[i] != (board_t *)0) {nodeFree(list_p->elements[i]);list_p->numElements--;}}return;}double evaluateBoard( board_t *board_p ){int i;const int test[MAX_BOARD-1]={1, 2, 3, 4, 5, 6, 7, 8 };int score=0;for (i = 0 ; i < MAX_BOARD-1 ; i++) {score += (board_p->array[i] != test[i]); }return (double)score;}int countInversions( char *array ){int i, j, inversions = 0;for (j = 0 ; j < MAX_BOARD-1 ; j++) {for (i = j+1 ; i < MAX_BOARD ; i++) {if (array[j] > array[i]) inversions++;}}return inversions;}board_t *initPuzzle( void ){int i, inversions;board_t *board_p;board_p = nodeAlloc();for (i = 0 ; i < MAX_BOARD-1 ; i++) {board_p->array[i] = i+1;}board_p->array[i] = 0;do {/* Randomize the board */for (i = 0 ; i < MAX_BOARD ; i++) {int x = RANDMAX(MAX_BOARD);int y = RANDMAX(MAX_BOARD);int temp = board_p->array[x];board_p->array[x] = board_p->array[y];board_p->array[y] = temp;}inversions = countInversions( board_p->array ); } while (inversions & 1);/* Find the blank space (we need to track it) */for (i = 0 ; i < MAX_BOARD ; i++) {if (board_p->array[i] == 0) {board_p->blank = i;break;}}board_p->f = board_p->h = evaluateBoard( board_p );/* Depth is zero -- top of the tree */board_p->depth = 0;return board_p;}void emitPuzzleBoard( board_t *board ){int i;assert(board);for (i = 0 ; i < MAX_BOARD ; i++) {if ((i%3) == 0) printf("\n");if (board->array[i] == 0) printf(" ");else printf("%c", 'A'+board->array[i]-1);}printf("\n");return;}#define MAX_VECTOR 4typedef struct {unsigned int len;unsigned int vector[MAX_VECTOR];} move_t;const move_t moves[MAX_BOARD] = {/* 0 */ { 2, {1, 3} },/* 1 */ { 3, {0, 2, 4} },/* 2 */ { 2, {1, 5} },/* 3 */ { 3, {0, 4, 6} },/* 4 */ { 4, {1, 3, 5, 7} },/* 5 */ { 3, {2, 4, 8} },/* 6 */ { 2, {3, 7} },/* 7 */ { 3, {4, 6, 8} },/* 8 */ { 2, {5, 7} } };board_t *getChildBoard( board_t *board_p, int index ){board_t *child_p = (board_t *)0;int blankSpot;int i;blankSpot = board_p->blank;if (index < moves[blankSpot].len) {int moveFrom;child_p = nodeAlloc();/* Copy board from parent to child */for (i = 0 ; i < MAX_BOARD ; i++) {child_p->array[i] = board_p->array[i];}child_p->blank = board_p->blank;moveFrom = moves[blankSpot].vector[index];child_p->array[ (int)child_p->blank ] = child_p->array[ moveFrom ];child_p->array[ moveFrom ] = 0;child_p->blank = moveFrom;}return child_p;}void showSolution( board_t *goal ){board_t *revList[MAX_LIST_ELEMENTS];int i = 0, j;printf("Solution:\n");while (goal) {revList[i++] = goal;goal = goal->pred;}for (j = i-1 ; j >= 0 ; j--) {emitPuzzleBoard( revList[j] );printf("\n");}return;}void astar( void ){board_t *cur_board_p, *child_p, *temp;int i;/* While items are on the open list */while ( listCount(&openList_p) ) {/* Get the current best board on the open list */ cur_board_p = getListBest( &openList_p );putList( &closedList_p, cur_board_p );/* Do we have a solution? */if (cur_board_p->h == (double)0.0) {showSolution( cur_board_p );return;} else {/* Heuristic - average number of steps is 22 for a 3x3, so don't go * too deep.*/if (cur_board_p->depth > MAX_DEPTH) continue;/* Enumerate adjacent states */for (i = 0 ; i < 4 ; i++) {child_p = getChildBoard( cur_board_p, i );if (child_p != (board_t *)0) {if ( onList(&closedList_p, child_p->array, NULL) ) {nodeFree( child_p );continue;}child_p->depth = cur_board_p->depth + 1;child_p->h = evaluateBoard( child_p );child_p->g = (double)child_p->depth;child_p->f = (child_p->g * ALPHA) + (child_p->h * BETA);/* New child board on the open list? */if ( onList(&openList_p, child_p->array, NULL) ) {assert( !onList(&closedList_p, child_p->array, NULL) );temp = getList(&openList_p, child_p->array);if (temp->g < child_p->g) {nodeFree(child_p);putList(&openList_p, temp);continue;}nodeFree( temp );} else {/* Child board either doesn't exist, or is better than a * previous board. Hook it to the parent and place on the * open list.*/child_p->pred = cur_board_p;putList( &openList_p, child_p );}}}}}return;}int main(){board_t *initial_p;RANDINIT();initList( &openList_p );initList( &closedList_p );initial_p = initPuzzle();putList( &openList_p, initial_p );astar();1.实验名称、实验目的、实验内容、实验要求由教师确定，实验前由教师事先填好，然后作为实验报告模版供学生使用；2.实验准备由学生在实验或上机之前填写，教师应该在实验前检查；3.实验过程由学生记录实验的过程，包括操作过程、遇到哪些问题以及如何解决等；4.实验总结由学生在实验后填写，总结本次实验的收获、未解决的问题以及体会和建议等；5.源程序、代码、具体语句等，若表格空间不足时可作为附录另外附页。
启发式搜索(共49张PPT)
其中：g(x)——从初始节点S0到节点x的实际代价； h(x)——从x到目标节点Sg的最优路径的评估代价，它体现了问
题的启发式信息，其形式要根据问题的特性确定，h(x)称为启发式 函数。
2022/10/14
6
评估函数
启发式方法把问题状态的描述转换 成了对问题解决程度的描述。
这一程度用评估函数的值来表示。
2022/10/14
7
评估函数
S
搜索图G
2022/10/14
n ng
初始状态节点S
f(n):s-n-ng的估计最小路径代价
g(n):s-n的实际路径代价 h(n): n-ng的估计最小路径代价
节点n
目标状态节点ng
8
启发式搜索A算法
A算法的设计与一般图搜索相同，划分为二个阶段：
IF f(ni)>f(n,ni) THEN 令f(ni)=f(n,ni)
修改指针指向新父结点n
排序OPEN表（f(n)值从小到大排序）
2022/10/14
10
2022/10/14
4功指1搜 未做.若.退针建扩C索nL出从立为展图O，n一S一节到GE个此,目的把点S只这解标已S表放条包是扩节中路到含追展点；径一节起踪，建而个点始图则立得叫表节G有一到中O，点解P个的沿其ES成N叫；的初着的
始为空表；
5.扩展节点n，同时生成不是n的 祖 M2出的.先若；这的OP些那EN成些表员子是作节空为点表n，的的则集后失合继败节M,退点把 添入搜索图G中；对于M中每个 子3把 表.节选中它点f择(，从nnO,称nOi,P计iP)E此EN=算N表节g表:(n上点移,n为的出i) +节并第h放点一(n进in)个；C节LO点SE，
搜索策略实验
实验一：搜索策略实验一、实验目的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表是用来存放考察过的状态节点，并且标记上当前节点的编号和父节点的编号，然后可以根据编号便可以形成一个搜索树，即可以找到一个解路径。
实验一启发式搜索
2. 启发式搜索过程的特性
（3）信息性
比较两个启发策略h1和h2，如果对搜索空间中的任何一个状态n都有h1(n) ≤h2(n)，就说h2比h1具有更多的信息 性。 一般而言，若搜索策略h2比h1有更多的信息性，则h2比h1考察的状态要少。但必须注意的是更多信息性需 要更多的计算时间，从而有可能抵消减少搜索空间所带来的益处。
谢谢大家
12.06.2021
生产计划部
在一个限定的环境下，瞎子爬山法可能会极大的提高搜索的效率，但是对整个搜索空间而言，可能 得不到全局最优解。
（2）最好优先搜索法（有序搜索法）
该算法的估价函数采用f(n) = g(n) + h(n)，在搜索过程中算法使用OPEN表和CLOSE表来记录节点信息： OPEN表中保留所有已生成而未考察的节点；CLOSE表中保留所有已访问过的节点。算法在每一次搜索过 程中都会对OPEN表中的节点按照每个节点的f值进行排序，选择f值最小节点进行扩展。
实验一启发式搜索
12.06.2021
生产计划部
一、实验目的：
熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A算法求解九宫问题，理解求解流程 和搜索顺序。
二、实验方法：
• 1.先熟悉启发式搜索算法； • 2.用C、C++或JAVA 语言编程实现实验内容。
三、实验背景知识
1.估价函数 在对问题的状态空间进行搜索时，为提高搜索效率需要和被解问题的解有关的大量控制性知识作为搜索的辅 助性策略。这些控制信息反映在估价函数中。 估价函数的任务就是估计待搜索节点的重要程度，给这些节点排定次序。估价函数可以是任意一种函数，如 有的定义它是节点x处于最佳路径的概率上，或是x节点和目标节点之间的距离等等。在此，我们把估价函数 f(n)定义为从初始节点经过n节点到达目标节点的最小代价路径的代价估计值，它的一般形式是： f(n) = g(n) + h(n) 其中g(n)是从初始节点到节点n的实际代价，g(n)可以根据生成的搜索树实际计算出来；h(n)是从n到目标节点 的最佳路径的代价估计，h(n)主要体现了搜索的启发信息。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
四、实验内容
问题描述： 用启发式搜索方法求解下列九宫问题
五、问题
（1）状态表示的数据结构 （2）状态扩展规则的表示 （3）搜索产生的状态空间图 （4）OPEN表和CLOSE表变化过程 （5）程序清单
六、实验结果讨论
a. 你所采用的估价函数f(n) = g(n) + h(n)中， g(n)和h(n)的主要作用是什么？ b. 结合本实验举例说明不同启发策略对实验 的效果有何影响？ c. 若问题的初始状态是随机产生的，你的实 验程序应该如何改进？
（2）最好优先搜索法（有序搜索法） • 该算法的估价函数采用f(n) = g(n) + h(n)，在 搜索过程中算法使用OPEN表和CLOSE表来记 录节点信息：OPEN表中保留所有已生成而 未考察的节点；CLOSE表中保留所有已访问 过的节点。算法在每一次搜索过程中都会 对OPEN表中的节点按照每个节点的f值进行 排序，选择f值最小节点进行扩展。
实验一 启发式搜索
一、实验目的：
熟悉和掌握启发式搜索的定义、估价函 数和算法过程，并利用A算法求解九宫问题， 理解求解流程和搜索顺序。
二、实验方法：
• 1.先熟悉启发式搜索算法； • 2.用C、C++或JAVA 语言编程实现实验内容。
三、实验背景知识
1.估价函数 • 在对问题的状态空间进行搜索时，为提高搜索效率需要和被解问 题的解有关的大量控制性知识作为搜索的辅助性策略。这些控制 信息反映在估价函数中。 • 估价函数的任务就是估计待搜索节点的重要程度，给这些节点排 定次序。估价函数可以是任意一种函数，如有的定义它是节点x处 于最佳路径的概率上，或是x节点和目标节点之间的距离等等。在 此，我们把估价函数f(n)定义为从初始节点经过n节点到达目标节 点的最小代价路径的代价估计值，它的一般形式是： f(n) = g(n) + h(n) • 其中g(n)是从初始节点到节点n的实际代价，g(n)可以根据生成的搜 索树实际计算出来；h(n)是从n到目标节点的最佳路径的代价估计， h(n)主要体现了搜索的启发信息。
2. 启发式搜索过程的特性 （1）可采纳性 • 当一个搜索算法在最短路径存在的时候能保证能找到 它，我们就称该算法是可采纳的。所有A*算法都是可 采纳的。 （2）单调性 • 一个启发函数h是单调的，如果 a） 对所有的状态ni和 nj，其中nj是ni的子孙， h(ni )- h(nj )≤cost(ni ,nj ),其中cost(ni ,nj )是从ni 到nj 实 际代价。 b） 目标状态的启发函数值为0，即h(Goal)=0. 具有单 调性的启发式搜索算法在对状态进行扩展时能保证所 有被扩展的状态的f值是单调递增（不减）。
算法的描述如下： ① 把起始节点S放到OPEN表中，计算f(S),并把其 值与节点S联系起来。 ② 若OPEN是个空表，则算法失败退出，无解。 ③ 从OPEN表中选择一个f值最小的节点i。结果有 几个节点合格，当其中有一个为目标节点时，则 选择此目标节点，否则就选择其中任一个节点作 为节点i 。 ④ 把节点i从OPEN表中移出，并把它放入到 CLOSED的扩展节点表中。 ⑤ 若节点i是个目标节点）信息性 比较两个启发策略h1和h2，如果对搜索空间中的 任何一个状态n都有h1(n) ≤h2(n)，就说h2比h1具 有更多的信息性。 一般而言，若搜索策略h2比h1 有更多的信息性，则h2比h1考察的状态要少。但 必须注意的是更多信息性需要更多的计算时间， 从而有可能抵消减少搜索空间所带来的益处。
⑥ 扩展i，生成其全部后继节点。对i的每个后继节点 j： （a） 计算f(j)。 （b） 如果j既不在OPEN表中，也不在CLOSED表中， 则用估价函数f将其添加到OPEN表。从j加一指向其 父辈节点i的指针，以便一旦找到目标节点时记住一 个解答路径。 （c） 如果j已则OPEN表中或CLOSED表中，则比较刚 刚对j计算过的f值和前面计算过的该节点在表中的f 的值。若新的f值较小，则 （i） 以此值取代旧值。 （ii） 从j指向i，而不是指向它的父辈节点。 （iii） 若节点j在CLOSED表中，则把它移回OPEN 表。 ⑦ 转向②。
3.常用的启发式搜索算法 （1）局部择优搜索算法（瞎子爬山法） 瞎子爬山法是最简单的启发式算法之一。 该算法在搜索过程中扩展当前节点并估价它 的子节点。最优的子节点别选择并进一步扩 展；该子节点的兄弟节点和父节点都不再被 保留。当搜索到达一种状态，该状态比它的 所有子状态都要好，则搜索停止。因此，该 算法的估价函数可表示为f(n) = h(n)。 在一个限定的环境下，瞎子爬山法可能 会极大的提高搜索的效率，但是对整个搜索 空间而言，可能得不到全局最优解。