用A算法解决八数码问题演示教学
a算法八数码问题例题
a算法八数码问题例题
八数码问题是一个经典的搜索问题，其中有一个3×3的格子，其中包含了一些数字（通常是1到8），以及一个空白格。目标是使用最少的步骤将格子中的数字排列成给定的目标顺序。每个步骤可以是以下三种操作之一：
1. 上下移动（将行中的某个数字上移或下移）
2. 左右移动（将列中的某个数字左移或右移）
3. 旋转（以中心为中心旋转整个格子）
下面是一个使用A算法解决八数码问题的例子：
假设初始状态如下：
```markdown
4 1 2 7
5
6 3 8 0
5 0 3 2 4 1
6
7 8
6 7 5 8 3 4 2 1 0
```
目标状态如下：
```markdown
1 2 3 4 5 6 7 8 0
0 3 6 7 4 5 8 1 2
7 8 5 6 1 2 3 4 0
```
下面是使用A算法解决这个问题的步骤：
1. 首先，我们需要构建一个优先级队列（例如最小堆），用于存储所有可能的移动。在这个例子中，每个移动都有一个成本和优先级。成本是从当前状态到目标状态的最短路径长度，优先级是当前状态到目标状态的H启发式估计。H启发式估计通常是当前状态和目标状态之间的曼哈顿距离。
2. 从队列中取出优先级最高（即成本最低）的移动。在这个例子中，初始状态的移动是"上下移动"。
3. 应用这个移动，并更新所有相关状态的成本和优先级。在这个例子中，我们将第一行向下移动一格。然后，我们需要重新评估所有可能的状态，并更新优先级队列。
4. 在更新优先级队列后，我们需要检查是否已经达到目标状态。如果已经达到目标状态，则算法结束。否则，我们重复步骤2和步骤3，直到达到目标状态。
用A星算法解决八数码问题
A*算法解决八数码问题
1 问题描述
什么是八数码问题
八数码游戏包括一个3×3的棋盘，棋盘上摆放着8个数字的棋子，留下一个空位。
与空位相邻的棋子可以滑动到空位中。游戏的目的是要达到一个特定的目标状态。标注的形式化如下：
问题的搜索形式描述
状态：状态描述了8个棋子和空位在棋盘的9个方格上的分布。
初始状态：任何状态都可以被指定为初始状态。
操作符：用来产生4个行动（上下左右移动）。
目标测试：用来检测状态是否能匹配上图的目标布局。
路径费用函数：每一步的费用为1，因此整个路径的费用是路径中的步数。
现在任意给定一个初始状态，要求找到一种搜索策略，用尽可能少的步数得到上图的目标状态。
解决方案介绍
算法思想
(
估价函数是搜索特性的一种数学表示，是指从问题树根节点到达目标节点所要耗费的全部代价的一种估算，记为f(n)。估价函数通常由两部分组成，其数学表达式为
f(n)=g(n)+h(n)
其中f(n) 是节点n从初始点到目标点的估价函数，g(n) 是在状态空间中从初始节点到n 节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。保证找到最短路径（最优解）的条件，关键在于估价函数h(n)的选取。估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。如果估价值>实际值, 搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。
搜索中利用启发式信息，对当前未扩展结点根据设定的估价函数值选取离目标最近的结点进行扩展，从而缩小搜索空间，更快的得到最优解，提高效率。
八数码问题C语言A星算法详细实验报告含代码
一、实验内容和要求
八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
例如：
图1 八数码问题示意图
请任选一种盲目搜索算法（广度优先搜索或深度优先搜索）或任选一种启发式搜索方法（全局择优搜索，加权状态图搜索，A 算法或A* 算法）编程求解八数码问题（初始状态任选）。选择一个初始状态，画出搜索树，填写相应的OPEN 表和CLOSED表，给出解路径，对实验结果进行分析总结，得出结论。
二、实验目的
1. 熟悉人工智能系统中的问题求解过程；
2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用；
3. 熟悉对八数码问题的建模、求解及编程语言的应用。
三、实验算法
A*算法是一种常用的启发式搜索算法。
在A*算法中，一个结点位置的好坏用估价函数来对它进行评估。A*算法的估价函数可表示为：
f'(n) = g'(n) + h'(n)
这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值（也称为最小耗费或最小代价），h'(n)是n到目标的最短路经的启发值。由于这个f'(n)其实是无法预先知道的，所以实际上使用的是下面的估价函数：
f(n) = g(n) + h(n)
其中g(n)是从初始结点到节点n的实际代价，h(n)是从结点n到目标结点的最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。用f(n)作为f'(n)的近似，也就是用g(n)代替g'(n)，h(n)代替h'(n)。这样必须满足两个条件：（1）g(n)>=g'(n)（大多数情况下都是满足的，可以不
a星算法求解八数码问题python
a星算法求解八数码问题python
一、介绍
八数码问题是一种经典的智力游戏，也是人工智能领域中的经典问题
之一。在这个问题中，有一个3×3的棋盘，上面摆着1至8这8个数字和一个空格，初始状态和目标状态都已知。要求通过移动数字，将
初始状态变换成目标状态。其中空格可以和相邻的数字交换位置。
为了解决这个问题，我们可以使用A*算法。本文将详细介绍如何用Python实现A*算法来求解八数码问题。
二、A*算法简介
A*算法是一种启发式搜索算法，常用于寻找最短路径或最优解等问题。它基于Dijkstra算法，并加入了启发式函数来加速搜索过程。
在A*算法中，每个节点都有两个估价值：g值和h值。g值表示从起
点到该节点的实际代价，h值表示从该节点到目标节点的估计代价。
启发式函数f(n) = g(n) + h(n) 表示从起点到目标节点的估计总代价。
A*算法采用优先队列来保存待扩展的节点，并按照f(n)值从小到大排
序。每次取出队头元素进行扩展，并将扩展出来的新节点按照f(n)值
插入队列中。当扩展出目标节点时，算法结束。
三、八数码问题的状态表示
在八数码问题中，每个状态都可以表示为一个3×3的矩阵。我们可以用一个一维数组来表示这个矩阵，其中0表示空格。
例如，初始状态可以表示为[2, 8, 3, 1, 6, 4, 7, 0, 5]，目标状态可以表
示为[1, 2, 3, 8, 0, 4, 7, 6, 5]。
四、A*算法求解八数码问题的步骤
1.将初始状态加入优先队列中，并设置g值和h值为0。
2.从队头取出一个节点进行扩展。如果该节点是目标节点，则搜索结束；否则，将扩展出来的新节点加入优先队列中。
A星算法求解八数码问题资料讲解
1,6பைடு நூலகம்4,
7,0,5
};
//八数码目标状态
int final_s[3][3]={
1,2,3,
8,0,4,
7,6,5
};
//------------------------------------------------------------------------
//添加节点函数入口，方法：通过插入排序向指定表添加
3、A*算法流程图,如图2
4、A*算法总结
4.1，把起始状态添加到开启列表。
4.2，重复如下工作：
a)寻找开启列表中f值最低的节点，我们称它为BESTNOE
b)把它切换到关闭列表中。
c)对相邻的4个节点中的每一个
*如果它不在开启列表，也不在关闭列表，把它添加到开启列表中。把BESTNODE作为这一节点的父节点。记录这一节点的f和g值
图2 A*算法流程图
p(n)，意为放错的数码与正确的位置距离之和。
由于实际情况中，一个将牌的移动都是单步进行的，没有交换拍等这样的操作。所以要把所有的不在位的将牌，移动到各自的目标位置上，至少要移动从他们各自的位置到目标位置的距离和这么多次，所以最有路径的耗散值不会比该值小，因此该启发函数h(n)满足A*算法的条件。
2、八数码问题的求解算法
2.1盲目搜索
宽度优先搜索算法、深度优先搜索算法
用A算法解决八数码问题
用A*算法解决八数码问题
一、 题目：八数码问题也称为九宫问题。在3×3的棋盘，有八个棋子，每个棋子上标有
1至8的某一数字，分歧棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要解决的问题是：任意给出一个初始状态和一个目标状态，找出一种从初始转酿成目标状态的移动棋子步数最少的移动步调。
二、 问题的搜索形式描述
状态：状态描述了8个棋子和空位在棋盘的9个方格上的分布。
初始状态：任何状态都可以被指定为初始状态。
操纵符：用来发生4个行动（上下左右移动）。
目标测试：用来检测状态是否能匹配上图的目标规划。
路径费用函数：每一步的费用为1，因此整个路径的费用是路径中的步数。
现在任意给定一个初始状态，要求找到一种搜索战略，用尽可能少的步数得到上图的目标状态算法介绍
三、解决方案介绍
1.A*算法的一般介绍
A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。对于几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价值，即 ()()()()()()**f g n sqrt dx nx dx nx dy ny dy ny =+--+--；
这样估价函数f 在g 值一定的情况下，会或多或少的受估价值h 的制约，节点距目标点近，h 值小，f 值相对就小，能包管最短路的搜索向终点的方向进行。明显优于盲目搜索战略。
A star 算法在静态路网
中的应用
2.算法伪代码
创建两个表，
OPEN 表保管所有已生成而未考察的节点，
CLOSED 表中记录已访问过的节点。算起点的估
价值，将起点放入OPEN 表。
用A算法解八数码问题
用A*算法解八数码问题
1.启发式搜索
广度优先搜索和双向广度优先搜索都属于盲目搜索，这在状态空间不大的情况下是很合适的算法，可是当状态空间十分庞大时，它们的效率实在太低，往往都是在搜索了大量无关的状态结点后才碰到解答，甚至更本不能碰到解答。
搜索是一种试探性的查寻过程，为了减少搜索的盲目性引，增加试探的准确性，就要采用启发式搜索了。所谓启发式搜索就是在搜索中要对每一个搜索的位置进行评估，从中选择最好、可能容易到达目标的位置，再从这个位置向前进行搜索，这样就可以在搜索中省略大量无关的结点，提高了效率。
2.A*算法
A*算法是一种常用的启发式搜索算法。
在A*算法中，一个结点位置的好坏用估价函数来对它进行评估。A*算法的估价函数可表示为：
f'(n) = g'(n) + h'(n)
这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值（也称为最小耗费或最小代价），h'(n)是n到目标的最短路经的启发值。由于这个f'(n)其实是无法预先知道的，所以实际上使用的是下面的估价函数：
f(n) = g(n) + h(n)
其中g(n)是从初始结点到节点n的实际代价，h(n)是从结点n到目标结点的最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。用f(n)作为f'(n)
（1）g(n)>=g'(n)的近似，也就是用g(n)代替g'(n)，h(n)代替h'(n)。这样必须满足两个条件：
（大多数情况下都是满足的，可以不用考虑），且f必须保持单调递增。（2）h必须小于等于实际的从当前节点到达目标节点的最小耗费h(n)<=h'(n)。第二点特别的重要。可以证明应用这样的估价函数是可以找到最短路径的。
用A星算法解决八数码问题
A*算法解决八数码问题
1 问题描述
什么是八数码问题
八数码游戏包括一个3×3的棋盘，棋盘上摆放着8个数字的棋子，留下一个空位。
与空位相邻的棋子可以滑动到空位中。游戏的目的是要达到一个特定的目标状态。标注的形式化如下：
问题的搜索形式描述
状态：状态描述了8个棋子和空位在棋盘的9个方格上的分布。
初始状态：任何状态都可以被指定为初始状态。
操作符：用来产生4个行动（上下左右移动）。
目标测试：用来检测状态是否能匹配上图的目标布局。
路径费用函数：每一步的费用为1，因此整个路径的费用是路径中的步数。
现在任意给定一个初始状态，要求找到一种搜索策略，用尽可能少的步数得到上图的目标状态。
解决方案介绍
算法思想
(
估价函数是搜索特性的一种数学表示，是指从问题树根节点到达目标节点所要耗费的全部代价的一种估算，记为f(n)。估价函数通常由两部分组成，其数学表达式为
f(n)=g(n)+h(n)
其中f(n) 是节点n从初始点到目标点的估价函数，g(n) 是在状态空间中从初始节点到n 节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。保证找到最短路径（最优解）的条件，关键在于估价函数h(n)的选取。估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。如果估价值>实际值, 搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。
搜索中利用启发式信息，对当前未扩展结点根据设定的估价函数值选取离目标最近的结点进行扩展，从而缩小搜索空间，更快的得到最优解，提高效率。
采用A算法解决八数码问题
人工智能实验一报告题目：采用A*算法解决八数码问题
姓名： XXX
学号： 10S003028
专业：计算机科学与技术
提交日期： 2011-05-04
目录
1问题描述........................................................................................................................... - 2 -
1.1待解决问题的解释............................................................................................... - 2 -
1.2问题的搜索形式描述............................................................................................ - 2 -
1.3解决方案介绍（原理）........................................................................................ - 3 -
2算法介绍........................................................................................................................... - 4 -
人工智能-A算法求解8数码问题
实验四 A*算法求解8数码问题
一、实验目的
熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解8数码难题，理解求解流程和搜索顺序。
二、实验原理
A*算法是一种启发式图搜索算法，其特点在于对估价函数的定义上。对于一般的启发式图搜索，总是选择估价函数f值最小的节点作为扩展节点。因此，f 是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点n的估价函数值为两个分量：从起始节点到节点n的实际代价g(n)以及从节点n 到达目标节点的估价代价h(n)，且h(n)<=h*(n)，h*(n)为n节点到目标节点的最优路径的代价。
八数码问题是在3×3的九宫格棋盘上，排放有8个刻有1～8数码的将牌。棋盘中有一个空格，允许紧邻空格的某一将牌可以移到空格中，这样通过平移将牌可以将某一将牌布局变换为另一布局。针对给定的一种初始布局或结构（目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。如图1所示表示了一个具体的八数码问题求解。
图1 八数码问题的求解
三、实验内容
1、参考A*算法核心代码，以8数码问题为例实现A*算法的求解程序（编程语言不限），要求设计两种不同的估价函数。
2、在求解8数码问题的A*算法程序中，设置相同的初始状态和目标状态，针对不同的估价函数，求得问题的解，并比较它们对搜索算法性能的影响，包括扩展节点数、生成节点数等。
3、对于8数码问题，设置与图1所示相同的初始状态和目标状态，用宽度优先搜索算法（即令估计代价h(n)＝0的A*算法）求得问题的解，记录搜索过程中的扩展节点数、生成节点数。
实验三：A星算法求解8数码问题实验讲解
if((q->f < p->f ||q->f == p->f) && (q->next->f > p->f || q->next->f == p->f)){
p->next = q->next; q->next = p; break; } q = q->next; } if(q->next == NULL) // 考虑插入的节点值比链表最后一个元素的 值更大 q->next = p; } } else head->next = p; }
11
{ int i,j,flag=0; for(i=0; i< 3 ; i++) for(j=0; j< 3 ;j++) if(s1[i][j] != s2[i][j]){flag = 1; break;} if(!flag) return 1; else return 0; }
//-----------------------------------------------------------------------// 判断后继节点是否存在于 Open 或 Closed表中函数入口 //-----------------------------------------------------------------------int exit_Node(struct Node * head,int s[3][3], struct Node *Old_Node) {
人工智能-A算法求解8数码问题
实验四A* 算法求解8数码问题
一、实验目的
熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解8 数码难题，理解求解流程和搜索顺序。
二、实验原理
A*算法是一种启发式图搜索算法，其特点在于对估价函数的定义上。对于一般的启发式图搜索，总是选择估价函数 f 值最小的节点作为扩展节点。因此，f 是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点n 的估价函数值为两个分量：从起始节点到节点n 的实际代价g(n) 以及从节点n 到达目标节点的估价代价h(n) ，且h(n)<=h*(n) ，h*(n) 为n 节点到目标节点的最优路径的代价。
八数码问题是在3×3 的九宫格棋盘上，排放有8 个刻有1～8数码的将牌。棋盘中有一个空格，允许紧邻空格的某一将牌可以移到空格中，这样通过平移将牌可以将某一将牌布局变换为另一布局。针对给定的一种初始布局或结构 (目标状态)，问如何移动将牌，实现从初始状态到目标状态的转变。如图1 所示表示了一个具体的八数码问题求解。
图 1 八数码问题的求解
三、实验内容
1、参考A*算法核心代码，以8 数码问题为例实现A*算法的求解程序(编程语言不限)，要求设计两种不同的估价函数。
2、在求解8 数码问题的A*算法程序中，设置相同的初始状态和目标状态，针对不同的估价函数，求得问题的解，并比较它们对搜索算法性能的影响，包括扩展节点数、生成节点数等。
3、对于8 数码问题，设置与图1所示相同的初始状态和目标状态，用宽度优先搜索算法(即令估计代价h(n) ＝0 的A*算法)求得问题的解，记录搜索过程中的扩展节点数、生成节点数。
AStar算法解决八数码问题说课讲解
A S t a r算法解决八数
码问题
5.核心代码
操作算子：
int solve() //搜索过程
{
P cur;
P p;
while(!open.empty()){
cur=open.top(); //open表
open.pop();
if(cur.s==t) return cur.id; //达到目标状态，返回当前节点的id
int x,y;
int ops=0;
while(cur.s[ops]!='0') ops++;
x=ops/N,y=ops%N; //空格所在位置
int r=cur.id;
if(x>0){ //空格向上移
p.s=cur.s;
swap(p.s[ops],p.s[ops-3]);
if(!mp[p.s]){
p.d=cur.d+1,p.w=calw(p.s),p.id=top+1;
open.push(p);
三、实验结果：
四、实验心得：
只是做了简单修改，只能解决些简单的问题，过于复杂的还不能实现，不过还是体会到了A*算法的厉害，也见识到了人工智能的神奇，会继续努力学习。
教师评价优良中及
格不
及
格
教师
签名
日
期
A star 算法 八数码问题 C++ 报告+代码+详细注释
二、程序运行测试
A*算法求解八数码问题
一、详细设计说明
1.评价函数
以当前状态下各将牌到目标位置的距离之和作为节点的评价标准。距离的定义
为：“某将牌行下标与目标位置行下标之差的绝对值 + 列下标与目标位置列下
标之差的绝对值”。距离越小，该节点的效果越好。某个状态所有将牌到目标位
置的距离之和用“h值”表示。
2.主要函数
2.1countH（state & st）;
countH函数功能是计算st状态的h值。
计算过程中将会用到rightPos数组，数组里记录的是目标状态下，0~9每
个将牌在九宫格里的位置（位置 = 行下标 * 3 + 列下标）。
2.2f（state * p）;
f()=h()+level
2.3look_up_dup(vector<state*> & vec, state * p);
在open表或close表中，是否存在指定状态p，当找到与p完全相等的节
点时，退出函数。
2.4search(state & start)；
在open表不为空时，按f值由小到大对open表中元素进行排序。
调用findZero()函数找到0值元素的位置。空格可以向上下左右四个方向
移动，前提是移动后不能越过九宫格的边界线。确定某方向可走后，空格
移动一步，生成状态p’。
此时，检查open表中是否已有p’，若有，更新p’数据；检查close表
中是否已有p’，若有，将p’从close表中删除，添加到open表中。
重复的执行这个过程，直到某状态的h值为零。
2.5dump_solution(state * q)；
八数码问题C语言A星算法详细实验报告含代码
一、实验容和要求
八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
例如：
(a) 初始状态(b) 目标状态
图1 八数码问题示意图
请任选一种盲目搜索算法（广度优先搜索或深度优先搜索）或任选一种启发式搜索方法（全局择优搜索，加权状态图搜索，A算法或A* 算法）编程求解八数码问题（初始状态任选）。选择一个初始状态，画出搜索树，填写相应的OPEN 表和CLOSED表，给出解路径，对实验结果进行分析总结，得出结论。
二、实验目的
1. 熟悉人工智能系统中的问题求解过程；
2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用；
3. 熟悉对八数码问题的建模、求解及编程语言的应用。
三、实验算法
A*算法是一种常用的启发式搜索算法。
在A*算法中，一个结点位置的好坏用估价函数来对它进行评估。A*算法的估价函数可表示为：
f'(n) = g'(n) + h'(n)
这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值（也称为最小耗费或最小代价），h'(n)是n到目标的最短路经的启发值。由于这个f'(n)其实是无法预先知道的，所以实际上使用的是下面的估价函数：
f(n) = g(n) + h(n)
其中g(n)是从初始结点到节点n的实际代价，h(n)是从结点n到目标结点的最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。用f(n)作为f'(n)的近似，也就是用g(n)代替g'(n)，h(n)代替h'(n)。这样必须满足两个条件：（1）g(n)>=g'(n)（大多数情况下都是满足的，可以不用考虑），且f必须保持单调递增。（2）h必须小于等于实际的从当前节点到达目标节点的最小耗费h(n)<=h'(n)。第二点特别的重要。可以证明应用这样的估价函数是可以找到最短路径的。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
用A算法解决八数码
问题
用A*算法解决八数码问题
一、 题目：八数码问题也称为九宫问题。在3×3的棋盘，有八个棋子，每个
棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要解决的问题是：任意给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
二、 问题的搜索形式描述
状态：状态描述了8个棋子和空位在棋盘的9个方格上的分布。
初始状态：任何状态都可以被指定为初始状态。
操作符：用来产生4个行动（上下左右移动）。
目标测试：用来检测状态是否能匹配上图的目标布局。
路径费用函数：每一步的费用为1，因此整个路径的费用是路径中的步数。
现在任意给定一个初始状态，要求找到一种搜索策略，用尽可能少的步数得到上图的目标状态算法介绍
三、 解决方案介绍
1.A*算法的一般介绍
A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。对
于几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价
值，即
()()()()()()**f g n sqrt dx nx dx nx dy ny dy ny =+--+--；
这样估价函数f 在g 值一定的情况下，会或多或少的受估价值h 的制
约，节点距目标点近，h 值小，f 值相对就小，能保证最短路的搜索向终点的方向进行。明显优于盲目搜索策略。
A star算法在静态路网中的应用
2.算法伪代码
创建两个表，OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。算起点的估价值，将起点放入OPEN表。
while(OPEN!=NULL)
{
从OPEN表中取估价值f最小的节点n;
if(n节点==目标节点)
{break;}
for(当前节点n 的每个子节点X)
{
算X的估价值;
if(X in OPEN)
{
if( X的估价值小于OPEN表的估价值 )
{把n设置为X的父亲;
更新OPEN表中的估价值; //取最小路径的估价值}
}
if(X inCLOSE)
{
if( X的估价值小于CLOSE表的估价值 )
{把n设置为X的父亲;
更新CLOSE表中的估价值;
把X节点放入OPEN //取最小路径的估价值}
}
if(X not inboth)
{把n设置为X的父亲;
求X的估价值;
并将X插入OPEN表中; //还没有排序}
}//end for
将n节点插入CLOSE表中;
按照估价值将OPEN表中的节点排序; //实际上是比较OPEN表内节点f的大小，从最小路径的节点向下进行。
}//end while(OPEN!=NULL)
保存路径，即从终点开始，每个节点沿着父节点移动直至起点，这就是你的路径.
四、源程序
#include
#include
#include
using namespace std;
constint ROW = 3;
constint COL = 3;
constint MAXDISTANCE = 10000;
constint MAXNUM = 10000;
int abs(int a)
{
if (a>0) return a;
else return -a;
}
typedefstruct _Node{
int digit[ROW][COL];
intdist; // 距离
intdep; // 深度
int index; // 索引值
} Node;
Node src, dest;
vector
boolisEmptyOfOPEN() { //判断Open表是否空
for (inti = 0; i if (node_v[i].dist != MAXNUM) return false; } return true; } boolisEqual(int index, int digit[][COL]) {//判断节点是否与索引值指向的节点相同 for (inti = 0; i< ROW; i++) for (int j = 0; j < COL; j++) { if (node_v[index].digit[i][j] != digit[i][j]) return false; } return true; } ostream& operator<<(ostream&os, Node& node) { for (inti = 0; i< ROW; i++) { for (int j = 0; j < COL; j++) os< os< } returnos; } void PrintSteps(int index, vector index = node_v[index].index; while (index != 0) { rstep_v.push_back(node_v[index]); index = node_v[index].index; } for (inti = rstep_v.size() - 1; i>= 0; i--) cout<< "Step " < < } void Swap(int& a, int& b) { //交换 int t; t = a; a = b;