实验一 启发式搜索
启发式搜索实验讲解
启发式搜索实验讲解实验三搜索推理技术启发式搜索算法—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)主要体现了搜索的启发信息。
(完整版)启发式搜索算法
人工智能基础实验报告实验名称：八数码问题姓名：张俊学号：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：开始程序只能运行一种方式即按照错位个数搜索，后经过查找相关资料，修改后可程序可进行选择，两种方法结合在一起根据选择运行。
启发式搜索
例：一字棋游戏
选择“最好优先”算法 每种状态都标记了启发值 简化了搜索过程
启发式搜索和估价函数
在智能活动中使用最多的不是具有完备性的算法，而 是不一定完备的启发式方法。 对问题空间进行搜索时，提高搜索效率需要有和解有 关的大量控制性知识作为搜索的辅助性策略。 控制信息反映在估价函数中。 估价函数的任务就是估计待搜索结点的重要程度。
状态空间
爬山法的变形
随机爬山法 首选爬山法 随机重新开始爬山法
5.2.2 最好优先搜索法
❖ 定义：
Best-first Search (Ordered Search) 在AI图解搜索中，结点扩展的顺序是根据待扩展结点
的评价函数值 f(x)来决定，即将评价函数值最佳的结 点最先扩展，搜索方法是靠 f 值指导搜索顺序的。
启发式搜索
❖ “启发” (heuristic) 是关于发现和发明规则及方法的 研究。在状态空间搜索中,启发式被定义成一系列规 则,它从状态空间中选择最有希望到达问题解的路径。
❖ 有信息的搜索策略——是一种在问题本身的定义之外 还利用问题的特定知识的策略。
启发性信息
❖ 启发性信息的种类 有效地帮助确定扩展节点的信息； 有效的帮助决定哪些后继节点应被生成的信息； 能决定在扩展一个节点时哪些节点应从搜索树上删除的信息。
❖ 如果h(n)=0，g(n)=d(n) 时，就是广度优先搜索法。一般讲在 f(n) 中，g(n)的比重越大，越倾向于广度优先搜索；h(n)的比 重越大，越倾向于深度优先搜索。
❖ 有了f(n)，就可以对各个待扩展结点的价值进行估计，从 OPEN表中选择出最有希望的结点扩展。
5.2.2 最好优先搜索法
f (n) g(n) h(n)
启发式搜索A
例 八数码难题。 在3＊3的棋盘上，摆 有八个棋子，每个棋子上标有1至 8的某一数字。棋盘中留有一个空格。空格周围的棋子 可以移到空格中。要求解的问题是，给出一种初始布 局（初始状态）和目标布局（目标状态），找到一种 移动的方法，实现从初始布局到目标布局的转变。
2 8 3 1 6 4 7 5
1 2 3 8 4 7 6 5
Temp=goal
n
Until head=tail
中国盒子。给定10个盒子排成一行，其中有两个相邻的 盒子是空的，其余盒子中有4个A和4个B，如图所示：
A
B
B
A
A
B
A
B
移动规则：任意两个相邻字母可移到空盒中去，但这两 字母的次序应保持不变。 目标：全部A在B的左边，如下图：
A A A A
B
B
B
B
编一程序，从键盘上输入一个初始状态，即一系列A和 B及两个0（表示两个空盒子）。找到一种达到目标状态 的步数最少的移动计划，并模拟显示移动过程。
方向 di dj 左 0 -1 上 -1 0 右 0 1
4 下 1 0
搜索策略 （BFS） 框图： 初始 head=0 Tail=0
初始化INIT;初始结点入队 结点出队out(temp) For r:=1 to 4 do temp1 ←temp change(temp) Check(temp) and not(dupe(temp)) y n In(temp) y Print {打印} Exit {退出}
设八数码中未到目标位置的数字个数为启发函数hn未到目标位置的数字个数n是结点编号如果两个结点的启发函数相等应该先选深度小的结点fn未到目标位置的数字个数结点n的深度hndepn搜索策略bfs框图
实验一 启发式搜索算法
实验一启发式搜索算法学号：**********班级：计科二班姓名：***一、实验内容：使用启发式搜索算法求解8数码问题。
1、编制程序实现求解8数码问题A *算法，采用估价函数()()()()w n f n d n p n ⎧⎪=+⎨⎪⎩， 其中：()d n 是搜索树中结点n 的深度；()w n 为结点n 的数据库中错放的棋子个数；()p n 为结点n 的数据库中每个棋子与其目标位置之间的距离总和。
2、 分析上述⑴中两种估价函数求解8数码问题的效率差别，给出一个是()p n 的上界 的()h n 的定义，并测试使用该估价函数是否使算法失去可采纳性。
二、实验目的：熟练掌握启发式搜索A *算法及其可采纳性。
三、实验原理：（一）问题描述在一个3*3的方棋盘上放置着1,2,3,4,5,6,7,8八个数码,每个数码占一格,且有一个空格。
这些数码可以在棋盘上移动，其移动规则是：与空格相邻的数码方格可以移入空格。
现在的问题是：对于指定的初始棋局和目标棋局，给出数码的移动序列。
该问题称八数码难题或者重排九宫问题。
（二）问题分析八数码问题是个典型的状态图搜索问题。
搜索方式有两种基本的方式，即树式搜索和线式搜索。
搜索策略大体有盲目搜索和启发式搜索两大类。
盲目搜索就是无“向导”的搜索，启发式搜索就是有“向导”的搜索。
启发式搜索:由于时间和空间资源的限制，穷举法只能解决一些状态空间很小的简单问题，而对于那些大状态空间的问题，穷举法就不能胜任，往往会导致“组合爆炸”。
所以引入启发式搜索策略。
启发式搜索就是利用启发性信息进行制导的搜索。
它有利于快速找到问题的解。
由八数码问题的部分状态图可以看出，从初始节点开始，在通向目标节点的路径上，各节点的数码格局同目标节点相比较，其数码不同的位置个数在逐渐减少，最后为零。
所以，这个数码不同的位置个数便是标志一个节点到目标节点距离远近的一个启发性信息，利用这个信息就可以指导搜索。
即可以利用启发信息来扩展节点的选择，减少搜索范围，提高搜索速度。
启发式搜索
Heuristic Search启发式搜索译 by 陈雪(QQ:53352894)必要条件∙递归算法主要概念启发式搜索的主要目标是使用一个估价函数去判断所有状态的“好坏”，以提高搜索找到解的效率。
通常，估价函数表示成一个函数或是一个状态，这个函数叫做“估价函数”例如：∙迷宫寻找出路的时候，到出口的欧几里德距离D=[(xI-xj)^2+(yI-yj)^2]1/2。
式中，D是点i和点j之间的距离； xI xj 是第i个点的坐标；yI yj是第j个点的坐标。
（译者注）∙当尝试在一场跳棋比赛中获胜时，能吃掉对手的最多棋子子设计估价函数直观地看，估价函数越优秀，搜索就更好（快）。
问题是：怎么评价估价函数的好坏呢？估价函数的好坏，取决于它评估一个状态好坏的能力。
例如，迷宫的例子，怎么计算到出口的距离？欧几里德距离也许非常的坏，甚至是非常小的迷宫，它也可能绕很多的路：一般来说，估价函数越好，搜索就越快。
一般来说，搜索时间和估价函数的准确性如下图：注意！一个似乎很“傻”的估价函数可以大大地提高程序的效率！（如果它非常完美地被使用）另一个重要概念是“可接受”，一个可接受的估价函数表示对于每个点都不存在“低估”的情况。
例如，迷宫的欧几里德距离启发函数是“低估”的，刚才的图例很清楚地说明了这一点。
方法1：启发式剪枝最简单也是最常用的启发式搜索是利用估价函数来剪枝。
假设我们的问题是要求找最小总花费。
对于一个可接受的估价函数，当前花费是A，启发函数返回了B，当前子问的最优解是A+B。
如果找到的一个解一个花费是C，C<A+B，这个状态就不必要搜索了。
这样编写和调试也比较简单（假设一个状态需要长时间而被剪掉……），且可以极大地提高程序效率。
它对DFS尤其有效。
方法2：最佳优先搜索这种方法好比就是贪心算法。
每次不扩展所有子结点，而是按“好坏程度”来扩展。
与贪心不同的是，贪心只尝试“最优”路径，但是BFS首先扩展“希望大”的，再扩展“希望小”的，如果结合上述描述，搜索会得到很好的结果。
rgzn
《人工智能》实验报告专业计算机科学与技术年级大三姓名吕小春学号 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表中并进行重新排序。
人工智能-启发式搜索
实验报告姓名：***学号：**********班级：软件二班实验名称：启发式搜索课程名称：人工智能实验日期：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)。
启发式搜索实验报告
启发式搜索实验报告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)，意为放错的数码与正确的位置距离之和。
人工智能实验搜索策略
实验一搜索策略一、实验内容1.熟悉和掌握启发式搜索的定义、估价函数和算法过程，比较不同算法的性能。
2.以八数码问题或路径规划等问题为例设计启发式搜索算法，改变启发函数，观察结果的变化，分析原因。
二、实验目的熟悉和掌握各种启发式搜索策略的思想，掌握A*算法的定义、估价函数和算法过程，理解求解流程和搜索顺序。
三、实验内容1、分别以各种搜索算法为例演示搜索过程，比较不同算法的性能；2、分析各种算法中的OPEN表CLOSE表的生成过程；3、分析估价函数对搜索算法的影响；4、以八数码问题或路径规划等问题为例设计启发式搜索算法，改变启发函数，观察结果的变化，分析原因。
四、实验记录搜索策略实验报告表一启发式搜索A*算法框图路径规划问题中的启发函数在之前的作业中我们就已经写过A*算法的程序代码。
在八数码路径规划问题中，利用A*算法去找出一条最短路，最要关注的就是估价函数，在本实验中，估价函数为路径代价g 和启发函数h之和。
进而我们需要关注启发函数。
在原启发函数的定义用该点到目标点的曼哈顿距离估计从该点到目标节点的代价。
源节点目标节点7 2 4 0 1 25 06 3 4 58 3 1 6 7 8源程序如下：def setH(self, endNode):for x in range(0, 3):for y in range(0, 3):for m in range(0, 3):for n in range(0, 3):if self.array2d[x][y] == endNode.array2d[m][n]:self.h += abs(x-m)+abs(y-n)上图中的多层循环意在取值该节点到目标节点的曼哈顿距离。
而在曼哈顿距离下的花销如下：一共需要26步完成。
并且程序执行速度也比较快。
欧式距离作为启发式def setH(self, endNode):for x in range(0, 3):for y in range(0, 3):for m in range(0, 3):for n in range(0, 3):if self.array2d[x][y] == endNode.array2d[m][n]:#self.h += abs(x-m)+abs(y-n)self.h += (abs(x-m)*abs(x-m) + abs(y-n)*abs(y-n)) ** 0.5用欧式距离代替曼哈顿距离发现同样是26步，可以知道26步是该情况解的最优解。
- 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)。 在一个限定的环境下，瞎子爬山法可能 会极大的提高搜索的效率，但是对整个搜索 空间而言，可能得不到全局最优解。