过程表示八数码问题
a算法八数码问题例题
a算法八数码问题例题八数码问题是一个经典的搜索问题，其中有一个3×3的格子，其中包含了一些数字（通常是1到8），以及一个空白格。
目标是使用最少的步骤将格子中的数字排列成给定的目标顺序。
每个步骤可以是以下三种操作之一：1. 上下移动（将行中的某个数字上移或下移）2. 左右移动（将列中的某个数字左移或右移）3. 旋转（以中心为中心旋转整个格子）下面是一个使用A算法解决八数码问题的例子：假设初始状态如下：```markdown4 1 2 756 3 8 05 0 3 2 4 167 86 7 5 8 3 4 2 1 0```目标状态如下：```markdown1 2 3 4 5 6 7 8 00 3 6 7 4 5 8 1 27 8 5 6 1 2 3 4 0```下面是使用A算法解决这个问题的步骤：1. 首先，我们需要构建一个优先级队列（例如最小堆），用于存储所有可能的移动。
在这个例子中，每个移动都有一个成本和优先级。
成本是从当前状态到目标状态的最短路径长度，优先级是当前状态到目标状态的H启发式估计。
H启发式估计通常是当前状态和目标状态之间的曼哈顿距离。
2. 从队列中取出优先级最高（即成本最低）的移动。
在这个例子中，初始状态的移动是"上下移动"。
3. 应用这个移动，并更新所有相关状态的成本和优先级。
在这个例子中，我们将第一行向下移动一格。
然后，我们需要重新评估所有可能的状态，并更新优先级队列。
4. 在更新优先级队列后，我们需要检查是否已经达到目标状态。
如果已经达到目标状态，则算法结束。
否则，我们重复步骤2和步骤3，直到达到目标状态。
5. 在这个例子中，我们需要进行多次上下移动、左右移动和旋转，才能将数字排列成目标顺序。
每次应用移动后，都需要重新评估所有可能的状态，并更新优先级队列。
八数码问题解释
八数码问题解释8数码问题又称9宫问题，源于一个古老的智力游戏。
说白了就是我们小时候玩的“华容道”。
意在给定的9格棋盘的8个格子内分别放一个符号，符号之间互不相同，剩下一格做为“出口”。
我们把8个符号在棋盘上的排列顺序称作8数码的状态，游戏要求给定一个初始的状态与一个终止状态，符号要经过若干次移动后由初态变成终态，这个过程中只有“出口”附近的符号可以朝“出口”的方向移动，且每次只能移动一个符号。
如下图所示，（其中我们用0表示出口，=》表示移动一次，=》*表示移动0-n次）：初态终态1 2 3 1 2 3 0 1 24 5 6 =》 4 5 6 =》* 3 4 57 8 0 7 0 8 6 7 82 解决方案通过观察我们可以发现每一次8数码的状态都可以通过移动字符变成有限的几种其他状态，比如上图中我们可以知道初态“出口”附近有8和6可以移动，那么这个初态可以经过移动得到两个新的状态。
我们人在玩这个游戏的时候，总是要做下面几个步骤：1．看看哪个符号可以移动。
2．判断一下哪个符号的移动最有利于到达终态。
3．选定一个符号并移动它。
4．判断是否到达终态，是则结束，否则就回到第一步。
而现在我们要使用机器来模拟这一过程，其步骤与人类类似，但不同的是，人在执行第二部的时候总是能预先判断未来好几步的局势，从而选出最有利的一步，而机器则不行，它要先得到一个状态才能知道这个状态下一步将会到哪些状态而无法像我们一样一次就看到后面几步的状态。
那么基本思想就是让机器穷尽由初态出发到达所有可能状态的路径，并从中找到有终态的路径作为问题的解。
2.1 A*算法就如我们上面说到的让机器找出所有的可能来得到问题的解，看起来似乎很简单，但问题在于一旦8数问题的解达到一定规模，机器所要穷尽的路径数量将变得极为庞大，无疑会消耗大量的时间和空间。
那么如何让机器像人一样在选择移动符号的时候总是能选择最有利的那一个呢？下面就要介绍启发式搜索中的一个算法A*算法来解决这个问题。
过程表示八数码问题
for(i=0;;i++)
if(status[i]==0)
break;//空格当前位置
for(j=0;;j++)
if(arr1[j]==i)
break;
while(status[0]!=1)
{
status[arr1[j%8]]=status[arr1[(j+1)%8]];
int arr2[8]={1,4,3,6,7,8,5,2};//用于第三步的循环
int arr3[6]={3,6,7,8,5,4};//用于第四、六步的循环
int arr4[8]={3,0,1,4,5,2,1,0};//用于第五步的循环
int arr5[4]={3,6,7,4};//用于第七、九步的循环
}
while(status[3]!=0);//第五步
cout<<"第5步结果:"<<endl;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cout<<status[i*3+j]<<" ";
cout<<endl;
}
i=3;//当前空格位置
}//第六步
cout<<"第6步结果:"<<endl;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cout<<status[i*3+j]<<" ";
用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的大小，从最小路径的节点向下进行。
八数码问题
+0*6!+
3*7!+(98)*
8!=
55596<9!
具体的原因可以去查查一些数学书，其中
123456789的哈希值是
0最小，876543210
的哈希值是（9!1）
最大，而其他值都在
0到（
9!1）
中，且均唯一。
Q5：如何使搜索只求得最佳的解？
要寻找这一系列中间状态的方法是搜索，但搜索很容易遇到时间和空间上的问题。以下就是搜
索的基本原理：
由
137246852状态可以衍生三个状态，假如选择
了
123746855，则又衍生三个状态，继续按某策略进
行选择，一直到衍生出的新状态为目标状态
END为止。
容易看出，这样的搜索类似于从树根开始向茎再向叶
括两步操作
ld，可能与平时玩这类游戏的习惯不符合，但这是为了和
ACM例题相统一。
对应地，每种操作引起的状态变化如下：
r：num值++
l：num值u：
有点复杂
int
t0=
9num%
10+
1
int
t1=
num/1e(t0)
int
t2=
t1%1000
END，所以优先级高。
在计算
difference和
manhattan时，推荐都将空格忽略，因为在
difference中空格可有可无，对整
体搜索影响不大。
考虑下面两个状态（左需要
3步到达
END态，右需要
4步到达
采用A算法解决八数码问题
人工智能实验一报告题目：采用A*算法解决八数码问题姓名： XXX学号： 10S003028专业：计算机科学与技术提交日期： 2011-05-04目录1问题描述........................................................................................................................... - 2 -1.1待解决问题的解释............................................................................................... - 2 -1.2问题的搜索形式描述............................................................................................ - 2 -1.3解决方案介绍（原理）........................................................................................ - 3 -2算法介绍........................................................................................................................... - 4 -2.1A*搜索算法一般介绍............................................................................................ - 4 -2.2 算法伪代码........................................................................................................... - 4 -3算法实现........................................................................................................................... - 5 -3.1 实验环境与问题规模........................................................................................... - 5 -3.2 数据结构............................................................................................................... - 5 -3.3 实验结果............................................................................................................... - 6 -3.4系统中间及最终输出结果.................................................................................... - 6 -4参考文献........................................................................................................................... - 7 - 5附录—源代码及其注释................................................................................................... - 7 -1问题描述所谓八数码问题是指这样一种游戏：将分别标有数字1，2，3，…，8 的八块正方形数码牌任意地放在一块3×3 的数码盘上。
A星算法求解八数码问题
A＊算法求解八数码问题1、八数码问题描述所谓八数码问题起源于一种游戏:在一个3×3的方阵中放入八个数码1、2、3、4、5、6、7、8，其中一个单元格是空的.将任意摆放的数码盘（城初始状态）逐步摆成某个指定的数码盘的排列（目标状态），如图1所示图1 八数码问题的某个初始状态和目标状态对于以上问题，我们可以把数码的移动等效城空格的移动.如图1的初始排列，数码7右移等于空格左移.那么对于每一个排列,可能的一次数码移动最多只有4中,即空格左移、空格右移、空格上移、空格下移。
最少有两种（当空格位于方阵的4个角时）.所以,问题就转换成如何从初始状态开始，使空格经过最小的移动次数最后排列成目标状态。
2、八数码问题的求解算法2。
1 盲目搜索宽度优先搜索算法、深度优先搜索算法2。
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)其中A＊算法中的g(n)根据具体情况设计为d(n），意为n节点的深度，而h(n）设计为图2 A＊算法流程图p(n),意为放错的数码与正确的位置距离之和。
产生式规则正向推理八数码
产生式规则正向推理八数码引言随着人工智能技术的发展，推理系统被广泛应用于各个领域。
八数码问题是一个经典的智力游戏，也是推理系统在解决复杂问题中的一个具体应用。
本文将详细介绍如何使用产生式规则进行正向推理解决八数码问题，包括问题描述、推理系统设计和具体的推理过程。
问题描述八数码问题是一个基于数字排序的游戏，游戏中有一个3x3的方格，其中包含1至8这些数字，空位用0表示。
初始状态下，数字是随机排列的，目标是通过交换数字的位置，使得方格中的数字按照从小到大的顺序排列，空位在最后。
例如，初始状态为：2 3 14 5 06 7 8目标状态为：1 2 34 5 67 8 0游戏规则允许将0与其上、下、左、右的数字进行交换，但不能交换对角线上的数字。
解决八数码问题的核心是找到一系列合法的操作步骤，将初始状态转化为目标状态。
本文将采用产生式规则正向推理的方法来解决这个问题。
推理系统设计为了使用产生式规则进行正向推理解决八数码问题，我们需要设计一个合适的推理系统。
推理系统由三个主要组成部分构成：知识库、工作内存和控制策略。
知识库知识库是推理系统存储知识的地方，它包含了一系列的产生式规则。
对于八数码问题，知识库中的规则描述了在不同状态下可以执行的操作步骤，并且规定了转化到下一状态的条件。
知识库的设计是解决问题的关键，需要考虑各个状态之间的转化关系，确保能够找到一条从初始状态到目标状态的路径。
工作内存工作内存用于存储推理过程中的中间结果和当前状态。
对于八数码问题，工作内存中需要包含当前状态的表示方式，以及记录已经执行的操作步骤和可行的下一步操作。
推理过程中，工作内存会不断更新和变化，直到找到解决问题的路径。
控制策略控制策略决定了推理系统如何进行推理。
针对八数码问题，控制策略需要确定推理的启动条件和终止条件，以及推理过程中的操作顺序。
合理的控制策略可以提高推理系统的效率和解决问题的成功率。
推理过程在了解了推理系统的设计之后，我们可以开始进行推理过程来解决八数码问题。
八数码
3
在众多的搜索算法中，在八数码问题上我选用的是宽度优先搜索和A*算法两种。
(1)宽度优先搜索
宽度优先搜索过程如下：
1）把起始节点放到OPEN表中。
2）如果OPEN是个空表，则没有解，失败退出；否则继续。
(d)比较新旧路径代价。如果g(SUC)＜g(OLD),则重新确定OLD的父辈节点为BESTNODE，记下较小代价g(OLD),并修正f(OLD)值。
(e)若至OLD节点的代价较低或一样，则停止扩展节点。
(f)若SUCCSSOR不在OPEN表中，则看其是否在CLOSED表中。
(g)若SUCCSSOR在CLOSED表中，则转向c。
③若在a中没有了该结点，则计算此结点的g、h、f和路径(与宽度优先搜索相同)，并把此结点加入到a中，并转到步骤①中。
(e)输出结果(与宽度优先搜索相同)。
5
本次将课本的理论知识变成现实是一大进步，前段时期，程序运行的有问题，经过不懈的努力，终于还是成功了，总结经验，主要没有注意细节的把握，要编写一个程序，会产生错误的概率是很高的，而能够完全按照自己的要求实现某些功能的概率是比较小的，所以，在编程的过程中，要考虑周全，更不能有想当然的思想。
1）把起始节点放到OPEN表中。
2）判断初始结点是否是目标结点，若是则成功，退出；否则继续。
3）如果OPEN是个空表，则没有解，失败退出；否则继续。
4）把第一个节点（节点n）从OPEN表移出，并把它放入CLOSED扩展节点表中。
5）扩展节点n，将其子节点放入OPEN表的尾部，并为每个子节点配置指向节点n的指针
八数码问题求解--实验报告讲解
实验报告一、实验问题八数码问题求解二、实验软件VC6.0 编程语言或其它编程语言三、实验目的1. 熟悉人工智能系统中的问题求解过程；2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用；3. 熟悉对八数码问题的建模、求解及编程语言的应用。
四、实验数据及步骤（一、）实验内容八数码问题：在3 ×3 的方格棋盘上，摆放着1 到8 这八个数码，有1 个方格是空的，其初始状态如图1 所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
2 83 1 2 31 4 8 47 6 5 7 6 5(a) 初始状态(b) 目标状态图1 八数码问题示意图(二、)基本数据结构分析和实现1. 结点状态我采用了struct Node 数据类型typedef struct _Node{int digit[ROW][COL];int dist; // distance between one state and the destination 个表和目的表的距离int dep; // the depth of node 深度// So the comment function = dist + dep. 估价函数值int index; // point to the location of parent 父节点的位置} Node; 2. 发生器函数定义的发生器函数由以下的四种操作组成：(1) 将当前状态的空格上移Node node_up;Assign(node_up, index);// 向上扩展的节点int dist_up = MAXDISTANCE;(2) 将当前状态的空格下移Node node_down;Assign(node_down, index);// 向下扩展的节点int dist_down = MAXDISTANCE;(3) 将当前状态的空格左移Node node_left;Assign(node_left, index);// 向左扩展的节点int dist_left = MAXDISTANCE;(4) 将当前状态的空格右移Node node_right;Assign(node_right, index);// 向右扩展的节点int dist_right = MAXDISTANCE;通过定义结点状态和发生器函数，就解决了8 数码问题的隐式图的生成问题。
八数码问题
八数码问题
八数码问题是一个经典的问题，也称为滑动谜题。
问题的描述是：在一个3x3的棋盘上，有1-8这8个数字和一个空格组成的九个格子，目标是通过移动数字，将棋盘上的数字按从小到大的顺序排列，空格在最后一个位置。
解决这个问题的算法主要有搜索算法，其中最常见的是A*算法。
A*算法是一种启发式搜索算法，通过建立一个状态空间图，并使用启发式函数估算每个状态到目标状态的距离，来优化搜索过程。
在八数码问题中，启发式函数可以使用曼哈顿距离来估算。
另外，也可以使用深度优先搜索、广度优先搜索、IDA*等搜索算法来解决八数码问题。
这些算法在搜索过程中以不同的方式遍历状态空间图，找到最优解。
解决八数码问题的具体步骤一般如下：
1. 定义初始状态和目标状态。
2. 使用搜索算法进行搜索，找到从初始状态到目标状态的最优解。
3. 在搜索过程中，需要注意状态的合法性和重复状态的处理。
4. 输出最优解，即一系列移动操作，将初始状态转化为目标状态。
需要注意的是，八数码问题可能存在无解的情况，需要在搜索过程中判断并处理无解情况。
此外，由于八数码问题的状态空间较大，搜索过程可能需要一定的时间和空间复杂度。
因此，在实现解决算法时，需要考虑性能优化的问题。
八数码问题详解
八数码问题详解（用bfs实现）注:下面要介绍的方法是LRJ大神首创的，笔者只是在巨人的肩膀上归纳总结了一下，有错误的还希望众大牛指点，本人定将不胜感激。
八数码问题也称为九宫问题。
在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。
棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。
要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
所谓问题的一个状态就是棋子在棋盘上的一种摆法。
棋子移动后，状态就会发生改变。
解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
如图：对这道题用bfs解决个人认为是个不错的方法，首先因为它有九个格子，那么便可以用state 数组记录他的的九个格子的数值，其中空格为0，后者由于它只有九个数，因此共有9！=362880种可能性，用bfs解决较快。
下面给出bfs实现的三种代码(这里的三种指的是对是否访问过已知节点的三种判断方法): 1.//用一套排列的编码和解码函数解决同一状态的再次访问//用统一的编码与解码函数避免同种状态的再次出现#include <stdio.h>#include <string.h>#include <stdlib.h>#include <math.h>#define len 362888 //状态共有362880种，数组稍微开大点#define le 9 //每种状态有9个数据,也可看为每种状态下又有9种状态typedefint state[le]; //状态：表示九个格子state st[len],goal; //st为状态数组goal为目标数组int dis[len],fact[le],head[len],vis[len],der[4][2]={{-1,0},{1,0},{0,-1},{0,1}}; //dis为每种状态的已走的步骤//der为方向:上，下，左，右void encode(){ //编码int i;for(i=fact[0]=1;i<le;i++)fact[i]=fact[i-1]*i;}int decode(int s){ //解码inti,j,code,cnt;for(i=code=0;i<le;i++){for(cnt=0,j=i+1;j<le;j++)if(st[s][i]>st[s][j])cnt++;code+=cnt*fact[8-i];}if(vis[code]) return 0;else return vis[code]=1;}intbfs(){int front=1,rear=2,i,x,y,z,nx,ny,nz;encode();while(front<rear){state& s=st[front];if(memcmp(s,goal,sizeof(s))==0) //对front状态和目标状态进行比较return front;for(i=0;i<le;i++) //找到为0的元素，即空的那个格子，这里选取空的那个格子是应为相对于1,2,3,...8这样的数据，0作为判断依据简单于用数据作为判断依据if(s[i]==0)break;x=i/3; y=i%3; z=i; //记录空的格子的行标，列表，和所在位置，这里的位置按照从左到右从上到下依次递增for(i=0;i<4;i++){ //按照上，下，左，右四个方向进行搜索nx=x+der[i][0];ny=y+der[i][1];nz=nx*3+ny;if(nx>=0&&nx<3&&ny>=0&&ny<3){state& t=st[rear];memcpy(&t,&s,sizeof(s)); //记录此时的状态即九个格子的数值t[z]=s[nz]; t[nz]=s[z];dis[rear]=dis[front]+1;if(decode(rear)) //判断st[rear]这种状态是否已经出现过rear++;}}front++;}return 0;}int main(void){intncase,i,oj;scanf("%d",&ncase);while(ncase--){memset(head,0,sizeof(head));memset(vis,0,sizeof(vis));for(i=0;i<le;i++) scanf("%d",&st[1][i]); //按从左到右从上到下的顺序存储数据for(i=0;i<le;i++) scanf("%d",&goal[i]);oj=bfs();if(oj)printf("%d\n",dis[oj]);elseputs("-1");}return 0;}2.//用hash避免同一状态的再次访问在讲这种方法之前建议读者先看一下算法导论中有关hash的介绍为了方便自己以后看的时候方便，先写一下有关hash的内容Hash表解决冲突三种hash函数：first：除法散列函数: h(k)=k mod m(m为所选的余数,最好选接近装载因子α=n/m，但又远离2的k次幂的质数)second：乘法散列法函数: 看图:具体代码实现下面有介绍third：全域散列函数h a,b(k)=((ak+b) mod p) mod m (p>m 且p和m都为质数)//用链表实现hash#include <stdio.h>#include <string.h>#include <stdlib.h>#include <math.h>#define len 362888 //状态共有362880种，数组稍微开大点#define le 9 //每种状态有9个数据,也可看为每种状态下又有9种状态typedefint state[le]; //状态：表示九个格子state st[len],goal; //st为状态数组goal为目标数组int dis[len],der[4][2]={{-1,0},{1,0},{0,-1},{0,1}}; //dis为每种状态的已走的步骤//der为方向:上，下，左，右typedefstruct node {int v;struct node *next;}ore;ore *head[len]; //这里的head为hash表ore * create_new_node(){ore *p;p=(ore *)calloc(1,sizeof(ore));p->next=NULL;return p;}//此处为哈希函数，不理解的建议看一下算法导论，下面用3种hash函数实现//first:除法散列法int hash(state& s){inti,num,m=372001; //m为所选的余数,最好选接近装载因子α=n/m，但又远离2的k次幂的质数for(i=num=0;i<le;i++)num=num*10+s[i];returnnum%m;}//second:乘法散列法int hash(state& s){inti,num;long longk,w=32,ss,r0,p=14,ans; //这里的w为需要截取的位数//p为要截取的数字长度const double A = (sqrt(5.)-1)/2;for(i=num=0;i<le;i++)num=num*10+s[i];k=(long long)num;ss=(long long)(A*(1LL<<w));r0=k*ss%(1LL<<w);ans=r0>>(w-p);returnans;}//third:全域散列hash functionint hash(state& s){inti,num;longlong a=3,b=4,m=350001,p=360001,k,ans;for(i=num=0;i<le;i++)num=num*10+s[i];k=(long long)num;ans=(a*k+b)%p%m; //此处为全域散列函数returnans;}//以上的三种hash function选取一种即可bool find(int s){int h;ore *u,*p;h=hash(st[s]); //通过hash function计算出hash值，并将该元素定义为head数组的下标u=create_new_node();if(!head[h]) //如果head[h]未创建，即未访问过，则创建一个新节点head[h]=create_new_node();u=head[h]->next; //u指向head[h]的下一个元素while(u){if(memcmp(st[u->v],st[s],sizeof(st[s]))==0) //如果找到memcmp(st[u->v],st[s],sizeof(st[s]))==0 的数据项则说明该节点已经访问过return false;u=u->next; //访问下一个节点//原理看下面的说明}p=create_new_node(); //创建一个新节点p->next=head[h]->next; //用头插法在散列表中插入新的节点head[h]->next=p;p->v=s;return true;}intbfs(){int front=1,rear=2,i,x,y,z,nx,ny,nz;while(front<rear){state& s=st[front];if(memcmp(s,goal,sizeof(s))==0) //对front状态和目标状态进行比较return front;for(i=0;i<le;i++) //找到为0的元素，即空的那个格子，这里选取空的那个格子是应为相对于1,2,3,...8这样的数据，0作为判断依据简单于用数据作为判断依据if(s[i]==0)break;x=i/3; y=i%3; z=i; //记录空的格子的行标，列表，和所在位置，这里的位置按照从左到右从上到下依次递增for(i=0;i<4;i++){ //按照上，下，左，右四个方向进行搜索nx=x+der[i][0];ny=y+der[i][1];nz=nx*3+ny;if(nx>=0&&nx<3&&ny>=0&&ny<3){state& t=st[rear];memcpy(&t,&s,sizeof(s)); //记录此时的状态即九个格子的数值t[z]=s[nz]; t[nz]=s[z];dis[rear]=dis[front]+1;if(find(rear)) //判断st[rear]这种状态是否已经出现过rear++;}}front++;}return 0;}int main(void){intncase,i,oj;scanf("%d",&ncase);while(ncase--){memset(head,0,sizeof(head));for(i=0;i<le;i++) scanf("%d",&st[1][i]); //按从左到右从上到下的顺序存储数据for(i=0;i<le;i++) scanf("%d",&goal[i]);oj=bfs();if(oj)printf("%d\n",dis[oj]);elseputs("-1");}return 0;}//基于链表的用数组实现hash#include <stdio.h>#include <string.h>#include <stdlib.h>#include <math.h>#define len 362888 //状态共有362880种，数组稍微开大点#define le 9 //每种状态有9个数据,也可看为每种状态下又有9种状态typedefint state[le]; //状态：表示九个格子state st[len],goal; //st为状态数组goal为目标数组int dis[len],head[len],next[len],der[4][2]={{-1,0},{1,0},{0,-1},{0,1}}; //dis为每种状态的已走的步骤//head为哈希表//next为链表//der为方向:上，下，左，右//此处为哈希函数，不理解的建议看一下算法导论，下面用3种hash函数实现//first:除法散列法int hash(state& s){inti,num,m=372001; //m为所选的余数,最好选接近装载因子α=n/m，但又远离2的k次幂的质数for(i=num=0;i<le;i++)num=num*10+s[i];returnnum%m;}//second:乘法散列法int hash(state& s){inti,num;long longk,w=32 /*这里的w为需要截取的位数*/ ,ss,r0,p=14 /*p为要截取的数字长度*/ ,ans;const double A = (sqrt(5.)-1)/2;for(i=num=0;i<le;i++)num=num*10+s[i];k=(long long)num;ss=(long long)(A*(1LL<<w));r0=k*ss%(1LL<<w);ans=r0>>(w-p);returnans;}//third:全域散列hash functionint hash(state& s){inti,num;longlong a=3,b=4,m=350001,p=360001,k,ans;for(i=num=0;i<le;i++)num=num*10+s[i];k=(long long)num;ans=(a*k+b)%p%m; //此处为全域散列函数returnans;}//以上的三种hash function选取一种即可bool find(int s){inth,u;h=hash(st[s]); //通过hash function计算出hash值，并将该元素定义为head数组的下标u=head[h]; //通过u获得head[h]的值while(u){ //如果前面已经访问过该项数据，则说明数据已经插入该项所对应的next数组中，则继续访问if(memcmp(st[u],st[s],sizeof(st[s]))==0) //如果找到memcmp(st[u],st[s],sizeof(st[s]))==0 的数据项则说明该节点已经访问过return false;u=next[u]; //访问下一个节点//原理看下面的说明}//这里的next其实是一个个链表的集合所组成的数组，不用链表的原因是应为链表的创建需要耗时，而且还要有多余的空间存储指针next[s]=head[h]; //这里的原理实际上是基于链表的头插法head[h]=s;return true;}intbfs(){int front=1,rear=2,i,x,y,z,nx,ny,nz;while(front<rear){state& s=st[front];if(memcmp(s,goal,sizeof(s))==0) //对front状态和目标状态进行比较return front;for(i=0;i<le;i++) //找到为0的元素，即空的那个格子，这里选取空的那个格子是应为相对于1,2,3,...8这样的数据，0作为判断依据简单于用数据作为判断依据if(s[i]==0)break;x=i/3; y=i%3; z=i; //记录空的格子的行标，列表，和所在位置，这里的位置按照从左到右从上到下依次递增for(i=0;i<4;i++){ //按照上，下，左，右四个方向进行搜索nx=x+der[i][0];ny=y+der[i][1];nz=nx*3+ny;if(nx>=0&&nx<3&&ny>=0&&ny<3){state& t=st[rear];memcpy(&t,&s,sizeof(s)); //记录此时的状态即九个格子的数值t[z]=s[nz]; t[nz]=s[z];dis[rear]=dis[front]+1;if(find(rear)) //判断st[rear]这种状态是否已经出现过rear++;}}front++;}return 0;}int main(void){intncase,i,oj;scanf("%d",&ncase);while(ncase--){memset(head,0,sizeof(head));memset(next,0,sizeof(next));for(i=0;i<le;i++) scanf("%d",&st[1][i]); //按从左到右从上到下的顺序存储数据for(i=0;i<le;i++) scanf("%d",&goal[i]);oj=bfs();if(oj)printf("%d\n",dis[oj]);elseputs("-1");}return 0;}3.用stl集合避免重复访问同一状态//用stl避免同一状态重复出现#include <stdio.h>#include <string.h>#include <stdlib.h>#include <math.h>#include <iostream>#include <set>using namespace std;#define len 362888 //状态共有362880种，数组稍微开大点#define le 9 //每种状态有9个数据,也可看为每种状态下又有9种状态typedefint state[le]; //状态：表示九个格子state st[len],goal; //st为状态数组goal为目标数组int dis[len],head[len],der[4][2]={{-1,0},{1,0},{0,-1},{0,1}}; //dis为每种状态的已走的步骤//der为方向:上，下，左，右structcmp{bool operator()(inta,int b)const{returnmemcmp(&st[a],&st[b],sizeof(st[a]))<0;}};set<int,cmp>vis;voidinit_lookup_table(){vis.clear();}inttry_to_insert(int s){if(vis.count(s)) return 0;vis.insert(s);return 1;}intbfs(){int front=1,rear=2,i,x,y,z,nx,ny,nz;init_lookup_table();while(front<rear){state& s=st[front];if(memcmp(s,goal,sizeof(s))==0) //对front状态和目标状态进行比较return front;for(i=0;i<le;i++) //找到为0的元素，即空的那个格子，这里选取空的那个格子是应为相对于1,2,3,...8这样的数据，0作为判断依据简单于用数据作为判断依据if(s[i]==0)break;x=i/3; y=i%3; z=i; //记录空的格子的行标，列表，和所在位置，这里的位置按照从左到右从上到下依次递增for(i=0;i<4;i++){ //按照上，下，左，右四个方向进行搜索nx=x+der[i][0];ny=y+der[i][1];nz=nx*3+ny;if(nx>=0&&nx<3&&ny>=0&&ny<3){state& t=st[rear];memcpy(&t,&s,sizeof(s)); //记录此时的状态即九个格子的数值t[z]=s[nz]; t[nz]=s[z];dis[rear]=dis[front]+1;if(try_to_insert(rear)) //判断st[rear]这种状态是否已经出现过rear++;}}front++;}return 0;}int main(void){intncase,i,oj;scanf("%d",&ncase);while(ncase--){memset(head,0,sizeof(head));for(i=0;i<le;i++) scanf("%d",&st[1][i]); //按从左到右从上到下的顺序存储数据for(i=0;i<le;i++) scanf("%d",&goal[i]);oj=bfs();if(oj)printf("%d\n",dis[oj]);elseputs("-1");}return 0;}。
人工智能-八数码游戏问题
if(The_graph->form[i][j]!=End_graph->form[i][j])
{
valute++;
}
}
}
The_graph->evalue=valute;
return valute;
}
/////////移动数码组
Graph *Move(Graph *The_graph,int Direct,int CreatNew_graph)
e、判断压入队的子节点数码组（优越点）的评估值，为零则表示搜索完成，退出搜索；
f、跳到步骤2；
四、数据结构的设计
数码结构体
typedef struct node//八数码结构体
{
int form[N][N];//数码组
int evalue;//评估值，差距
int udirec;//所屏蔽方向,防止往回推到上一状态,1上2下3左4右
struct node *parent;//父节点
}Graph;
Graph *Qu[MAX]; //队列
Graph *St[MAX]; //堆栈
/////////打印数码组
void Print(;
if(The_graph==NULL)
printf("图为空\n");
#define N 3 //数码组大小
#define Max_Step 50 //最大搜索深度
#define MAX 50
typedef struct node//八数码结构体
{
int form[N][N];//数码组
int evalue;//评估值
int udirect;//所屏蔽方向，防止往回推到上已状态，1上2下3左4右
八数码问题-实验报告(含源码)
人工智能基础实验报告题目：八数码问题一、内容 (2)二、目的 (2)三、实验设计思想和流程 (2)四、主要数据结构及符号说明 (3)五、程序初值及运行结果 (5)附录（源代码及注释） (6)一、内容八数码问题由8个编号1~8并放在3*3方格棋盘上的可走动的棋子组成。
棋盘上有一个格是空的，以便可以让空格周围的棋子走进空格，这也可以理解为移动空格。
给出起始状态和目标状态。
用A*算法求解出移动的路径。
二、目的1、学会用状态空间法来进行知识表示2、理解A*算法三、实验设计思想和流程1.八数码问题的状态表示八数码问题的一个状态就是八个数字在棋盘上的一种放法。
每个棋子用它上面所标的数字表示，并用0表示空格，这样就可以将棋盘上棋子的一个状态存储在一个二维数组中。
2、结点扩展规则搜索就是按照一定规则扩展已知结点，直到找到目标结点或所有结点都不能扩展为止。
八数码问题的结点扩展应当遵守棋子的移动规则。
按照棋子移动的规则，每一次可以将一个与空格相邻棋子移动到空格中，实际上可以看作是空格作相反移动。
空格移动的方向可以是右、下、左、上，当然不能移出边界。
3、A*算法A*算法是一种常用的启发式搜索算法。
在A*算法中，一个结点位置的好坏用估价函数来对它进行评估。
A*算法的估价函数可表示为：f'(n) = g'(n) + h'(n)这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值（也称为最小耗费或最小代价），h'(n)是n到目标的最短路经的启发值。
由于这个f'(n)其实是无法预先知道的，所以实际上使用的是下面的估价函数：f(n) = g(n) + h(n)其中g(n)是从初始结点到节点n的实际代价，h(n)是从结点n到目标结点的最佳路径的估计代价。
在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。
用f(n)作为f'(n)的近似，也就是用g(n)代替g'(n)，h(n)代替h'(n)。
八数码问题解释
8数码问题又称9宫问题，源于一个古老的智力游戏。
说白了就是我们小时候玩的“华容道”。
意在给定的9格棋盘的8个格子内分别放一个符号，符号之间互不相同，剩下一格做为“出口”。
我们把8个符号在棋盘上的排列顺序称作8数码的状态，游戏要求给定一个初始的状态与一个终止状态，符号要经过若干次移动后由初态变成终态，这个过程中只有“出口”附近的符号可以朝“出口”的方向移动，且每次只能移动一个符号。
如下图所示，（其中我们用0表示出口，=》表示移动一次，=》*表示移动0-n次）：初态终态1 2 3 1 2 3 0 1 24 5 6 =》 4 5 6 =》* 3 4 57 8 0 7 0 8 6 7 82 解决方案通过观察我们可以发现每一次8数码的状态都可以通过移动字符变成有限的几种其他状态，比如上图中我们可以知道初态“出口”附近有8和6可以移动，那么这个初态可以经过移动得到两个新的状态。
我们人在玩这个游戏的时候，总是要做下面几个步骤：1．看看哪个符号可以移动。
2．判断一下哪个符号的移动最有利于到达终态。
3．选定一个符号并移动它。
4．判断是否到达终态，是则结束，否则就回到第一步。
而现在我们要使用机器来模拟这一过程，其步骤与人类类似，但不同的是，人在执行第二部的时候总是能预先判断未来好几步的局势，从而选出最有利的一步，而机器则不行，它要先得到一个状态才能知道这个状态下一步将会到哪些状态而无法像我们一样一次就看到后面几步的状态。
那么基本思想就是让机器穷尽由初态出发到达所有可能状态的路径，并从中找到有终态的路径作为问题的解。
2.1 A*算法就如我们上面说到的让机器找出所有的可能来得到问题的解，看起来似乎很简单，但问题在于一旦8数问题的解达到一定规模，机器所要穷尽的路径数量将变得极为庞大，无疑会消耗大量的时间和空间。
那么如何让机器像人一样在选择移动符号的时候总是能选择最有利的那一个呢？下面就要介绍启发式搜索中的一个算法A*算法来解决这个问题。
人工智能-八数码游戏问题
一、八数码游戏问题简介九宫排字问题(乂称八数码问题)是人工智能当中有名的难题之一。
问题是在3X3方格盘上，放有八个数码，剩下第九个为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始位置转化为目标位置。
八数码游戏二、实验目的1 .熟悉人工智能系统中的问题求解过程；2 .熟悉状态空间的盲目搜索和启发式搜索算法的应用;3 .熟悉对八数码问题的建模、求解及编程语言的应用。
三、实验的思路八数码问题：在3X3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
例如:实验八数码游戏问题(a)初始状态图 (b)目标状态图1八数码问题示意图1 .启发函数设定由八数码问题的部分状态图可以看出，从初始节点开始，在通向目标节点的路径上，各节点的数码格局同目标节点相比较，其数码不同的位置个数在逐渐减少，最后为零，因此可以把数码不同的位置个数作为标志一个节点到目标节点距离远近的一个启发性信息，利用这个信息来扩展节点的选择，减少搜索范围，提高搜索速度。
2 .搜索过程：（搜索采用广度搜索方式，利用待处理队列辅助，逐层搜索（跳过劣质节点））a 、把初始数码组压入队列；b 、从队列中取出一个数码组节点；c 、扩展子节点，即从上下左右四个方向移动空格，生成相应子节点：d 、对子节点数码组作评估，是否为优越节点，即其评估值是否小于等于其父节点加一，是则将其压入队，否则抛弃。
e 、判断压入队的子节点数码组（优越点）的评估值，为零则表示搜索完成，退出搜索；f 、跳到步骤2；四、数据结构的设计//八数码结构体 〃数码组 〃评估值，差距 〃所屏蔽方向，防止往回推到上一状态,1上2下3左4 〃父节点数码结构体typedefstnictnode(intfonn[N][N];intevalue;intudirec;右stmctnode"parent;}Graph;Giaph*Qu[MAX];〃队歹lj起始五、实验过程及代码#mclude<stdio.h>}〃设计了搜索深度范围，防止队列内存越界#include<stdlib.h>#include<tnne.h>#defineN3〃数码组大小#defineMax_Step50〃最大搜索深度#defineMAX50typedefstinctnode//八数码结构体{intform[N][N];〃数码组intevahie;//评估值intudirect;〃所屏蔽方向，防止往回推到上已状态，1上2下3左4右stiuctnode*parent;〃父节点}Graph;Graph*Qu[MAX];//队歹ijGi-aph*St[MAX];〃堆栈〃/〃/〃/打印数码组voidPrint(Graph*The_graph){mtij;if(The_gi-aph=NULL)pnntf(”图为空\n)else{pnntff\n M);for(i=0;i<N;i++)(pmitf(n|\t H);for(j=0;j<N;j++)(printff^d't'Thjgraph->fbrm[i][j]);〃遍历打印}pinitfC,\t|\n n);}pniitf(n|\t\t\t差距:%d\t|\ir：The_graph->evahie);//差距显示pnntff\n M); ))〃//〃/〃评价函数mtEvaluate(Graph*The_gi'aph,Graph*End_graph){int\T alute=O;//差E巨数mtij;fbr(i=O;i<N;i-H-){for(j=0;j<N;j++)(if(The_graph->fbmi[i]|j]!=End_gi'aph->fonn[i][j])(valute++;}}}The_giaph->evalue=x r alute;returnvalute;}/〃/〃/〃移动数码组Graph*Move(Graph*Tlie_gi'aph,mtDirect,intCreatNew_graph){ Graph*New_graph;intHasGetBlank=O;〃是否获取空格位置intAbleMove=1;〃是否可移动intfor(i=0;i<N;i++)〃获取空格坐标ij{for(j=0;j<N;j++)(if(The_graph->fbim[i][j]=0)(HasGetBlaiik=l;break;}}if(HasGetBlank=l)break;}〃prin氓”空格位置:%d,%d\n”,i,j);t户U=J；〃移动空格switch(Direct){case1://_Etj-sif(t_i<0)AbleMove=0;break;case27/Ft_i++;if(t_i>=N)AbleMove=0;break;case3://左if(U<o)AbleMove=0;break;case4://右tj++;if(tj>=N)AbleMove=0;break;}if(AbleMove==0)〃不能移动则返回原节点{returnThe_graph;)if(CreatNew_gi,aph=1){New_graph=(Graph*)malloc(sizeof(Graph));//生成节点for(x=0;x<N;x++)( fbr(y^O;y<N;y++)(New_gi,aph->fbnn[x][y]=The_graph->fomi[x][y];//目制数码组}})elseNew_graph=The_graph;}〃移动后New_graph->fdmi[i][j]=New_gi-aph->fbnn[t_i][tj];New_graph->fbnn[t_i][t_j]=O;//pnntf("移动产生的新图:\n");//Print(New_graph);retiimNew_graph;}/〃/〃/〃搜索函数Graph*Search(Graph"Begin,Graph*End){Graph*gl,*g2,*g;intStep=O;〃深度intDirect=O;〃方向inti;intfront,rear;fiont=i-eai--l-Jf队列初始化g=NULL;reai++;〃入队Qu[rear]=Begin;while(rear!=fixmt)〃队列不空{fhmHT;〃出队gl=Qu[front];“printf("开始第％d个图ont);//Pimt(gl);for(i=1;iv=4;i++)〃分别从四个方向推导出新子节点(Duect=i;if(Du-ect=g1->udirect)〃跳过屏蔽方向contmue;g2=Move(gl,Direct,1)；〃移动数码组if(g2!=gl)〃数码组是否可以移动(〃可以移动Evahiate(g2,End);〃评价新的节点〃pnntf("开始产生的第％d个图://Print(g2);if(g2->evalue<=gl->evalue+1)〃是优越节点g2->parent=gl;〃移动空格switch(Direct)〃设置屏蔽方向，防止往回推(case1://Jtg2->udirect=2;break;case2:〃下g2->udu,ect=l;break;case3:〃左g2->udkect=4;break;case4:〃右g2->udirect=3;break;)rear4-+;Qu[rear]=g2;〃存储节点到待处理队列if(g2->evalue==0)〃为0则搜索完成(g=g2；//i=5;break;)}else(丘ee(g2);〃抛弃劣质节点g2=NULL;})}if(g!=NULL)〃为0则搜索完成(if(g->evalue==O)break;Step++;〃统计深度if(Step>Max_Step)break;}}retiinig;}mtmam(mtargc?constchar*argv口){//insertcodehere...GraphBegm_graph={{{2,8,3},{1,6,4},{7,0,5}},0,0,NULL)；/*IGraphBegm_graph={{{2,8,3},{1,0,4},{7,6,5}},0,0,NULL)；GraphBegm_graph={{{2,0,1},{4,6,5},{3,7,8}},0,0,NULL)；*/〃目标数码组GraphEnd_graph={{{1,2,3},{8,0,4},{7,6,5}},0,0,NULL)；Evaluate(&Begin_gi,aph,&End_graph);//对初始的数码组评价pnntf("初始数码组:\n”)；Pnnt(&Begm_graph);pnntf("目标数码组An")；Pnnt(&End_giaph);Graph*G,*P:inttop=-l;〃图搜索G=Search(&Begm_graph,&End_graph);〃打印if(G){〃把路径倒序P=G;〃压栈while(P!=NULL)(top++;St[top]=P;P=P->parent;}pnntf(y<v<vvvvvvvvvvv搜索结^»»»»»»»»\ii H);〃弹栈打印while(top>-l)(P=St[top];top--;Prmt(P);}pniitf(n<««««««««^Mc»»»>»»»»»>^i n);}else{prmtf("搜索不到结果，深度为％dW,Max_Step);〃设计搜索深度范围主要是防止队列内存越界)retiim0;六、实验结果。
八数码问题 算法流程
八数码问题算法流程下载温馨提示:该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。
文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by theeditor. I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!1. 问题定义：八数码问题是在一个 3x3 的棋盘上，有 8 个数字（1-8）和一个空格，通过移动空格，使得棋盘上的数字最终排列成目标状态。
八数码问题,实验报告
八数码问题,实验报告八数码实验报告利用人工智能技术解决八数码游戏问题1．八数码游戏问题简介九宫排字问题（又称八数码问题）是人工智能当中有名的难题之一。
问题是在3×3方格盘上，放有八个数码，剩下第九个为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始位置转化为目标位置。
2．八数码游戏问题的状态空间法表示①建立一个只含有初始节点S0的搜索图G，把S0放入OPEN表中②建立CLOSED表，且置为空表③判断OPEN表是否为空表，若为空，则问题无解，退出④选择OPEN表中的第一个节点，把它从OPEN表移出，并放入CLOSED表中，将此节点记为节点n⑤考察节点n是否为目标节点，若是，则问题有解，成功退出。
问题的解就是沿着n到S0的路径得到。
若不是转⑥⑥扩展节点n生成一组不是n的祖先的后继节点，并将它们记为集合M，将M中的这些节点作为n的后继节点加入图G中⑦对未在G中出现过的（OPEN和CLOSED表中未出现过的）集合M中的节点, 设置一个指向父节点n的指针，并把这些节点放入OPEN表中；对于已在G中出现过的M中的节点，确定是否需要修改指向父节点的指针；对于已在G中出现过并已在closed表中的M中的节点，确定是否需要修改通向他们后继节点的指针。
⑧按某一任意方式或某种策略重排OPEN表中节点的顺序⑨转③3．八数码游戏问题的盲目搜索技术宽度优先搜索：1、定义如果搜索是以接近起始节点的程度依次扩展节点的，那么这种搜索就叫做宽度优先搜索(breadth-first search)。
2、特点这种搜索是逐层进行的；在对下一层的任一节点进行搜索之前，必须搜索完本层的所有节点。
3、宽度优先搜索算法(1) 把起始节点放到OPEN表中(如果该起始节点为一目标节点，则求得一个解答)。
(2) 如果OPEN是个空表，则没有解，失败退出；否则继续。
(3) 把第一个节点(节点n)从OPEN表移出，并把它放入CLOSED 的扩展节点表中。
八数码问题文库
八数码实验报告八数码实验报告：03122997学校：上海大学学院：计算机学院关键字：八数码、人工智能、A*算法、双向广搜、启发式函数摘要：九宫排字问题（又称八数码问题）是人工智能当中有名的难题之一。
问题是在3×3方格盘上，放有八个数码，剩下第九个为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始位置转化为目标位置。
本文介绍用普通搜索方法、双向广度搜索和启发式搜索如何缩短寻找路径的时间，以及各算法间的利与弊。
目录：问题简介问题分析算法设计程序实现相关链接问题简介：所谓八数码问题是指这样一种游戏：将分别标有数字1，2，3，…，8的八块正方形数码牌任意地放在一块3×3的数码盘上。
放牌时要求不能重叠。
于是，在3×3的数码盘上出现了一个空格。
现在要求按照每次只能将与空格相邻的数码牌与空格交换的原则，将任意摆放的数码盘逐步摆成某种特殊的排列。
如下图表示了一个具体的八数码问题求解。
问题分析：首先，八数码问题包括一个初始状态(START)和目标状态(END)，所谓解八数码问题就是在两个状态间寻找一系列可过渡状态（START>STATE1>STATE2>...>END）。
这个状态是否存在就是我们要解决的第一个问题：Q1：每一个状态及每一次操作的表示方法？有许多表示方法，比如一个3*3的八数码盘可以压缩成一个int值表示，但不适用于15puzzle或大于8的puzzle问题。
如果对空间要求很高，应该还可以再压缩。
本文采用一个int表示的方法。
表示方法如下：由于int的表示范围大于1e9，所以我们取一个int的低9位，为了方便寻找空格的位置，int的个位我们用来放空格的位置（19）。
而前8位，按照行从上到下，列从左到右的顺序依次记录对应位置上的数字。
例如：成231584675，个位的5表示空格在第5位，前八位数按顺序记录。
8数码问题
高级人工智能程序设计报告题目：8数码问题学院：计算机学院专业：软件工程学号：2111505127姓名：马隆杰高级人工智能程序设计说明报告1.问题八数码游戏（八数码问题）描述为：在3×3组成的九宫格棋盘上，摆有八个将牌，每一个将牌都刻有1-8八个数码中的某一个数码。
棋盘中留有一个空格，允许其周围的某一个将牌向空格移动，这样通过移动将牌就可以不断改变将牌的布局。
这种游戏求解的问题是：给定一种初始的将牌布局或结构（称初始状态）和一个目标的布局（称目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。
初始状态：8个数字将牌和空格在九宫格棋盘上的所有格局组成了问题的状态空间。
其中，状态空间中的任一种状态都可以作为初始状态。
后继函数：通过移动空格（上、下、左、右）和周围的任一棋子一次，到达新的合法状态。
目标测试：比较当前状态和目标状态的格局是否一致。
路径消耗：每一步的耗散值为1，因此整个路径的耗散值是从起始状态到目标状态的棋子移动的总步数。
2.采用技术方法对于八数码问题的解决，首先判断是否有解。
每一个状态看作是一个3×3或1×9的矩阵，问题即通过矩阵的变换，是否可以变换为目标状态对应的矩阵？由数学知识可知，可计算这两个有序数列的逆序值，如果两者都是偶数或奇数，则可通过变换到达，否则，这两个状态不可达。
这样，就可以在具体解决问题之前判断出问题是否可解，从而可以避免不必要的搜索。
如果初始状态可以到达目标状态，那么采取什么样的方法呢？常用的状态空间搜索有深度优先和广度优先。
广度优先是从初始状态一层一层向下找，直到找到目标为止。
深度优先是按照一定的顺序前查找完一个分支，再查找另一个分支，以至找到目标为止。
广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。
这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不预测的情况下就不可取了。
他的效率实在太低，甚至不可完成。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
for(i=0;i<3;i+j++)
cout<<status[i*3+j]<<" ";
cout<<endl;
j++;
}
}
else if(status[2]==0)
{
i=2;
for(j=0;;j++)
if(circle2[j]==i)
break;
while(status[2]==1||status[2]==0)
{
status[circle2[j%8]]=status[circle2[(j+1)%8]];
cout<<endl;
}
for(i=0;;i++)
if(status[i]==0)
break;//空格当前位置
for(j=0;;j++)
if(arr1[j]==i)
break;
while(status[0]!=1)
{
status[arr1[j%8]]=status[arr1[(j+1)%8]];
status[arr3[(j+1)%6]]=0;
j++;
}//第六步
cout<<"第6步结果:"<<endl;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cout<<status[i*3+j]<<" ";
#include<iostream>
using namespace std;
void main()
{
int i,j;
int circle1[8]={0,3,6,7,8,5,2,1};
{
i=4;
for(j=0;;j++)
if(circle2[j]==i)
break;
while(status[2]==1||status[2]==0)
{
status[circle2[j%8]]=status[circle2[(j+1)%8]];
status[circle2[(j+1)%8]]=0;
cout<<"原问题无解!";
}
status[arr3[(j+1)%6]]=0;
j++;
}//第四步
cout<<"第4步结果:"<<endl;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cout<<status[i*3+j]<<" ";
}
i=3;
lop9: for(j=0;;j++)
if(arr5[j]==i)
break;
while(status[7]!=6)
{
status[arr5[j%4]]=status[arr5[(j+1)%4]];
status[arr5[(j+1)%4]]=0;
j++;
}//第九步
if(status[3]==8&&status[6]==7)
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cout<<status[i*3+j]<<" ";
cout<<endl;
}
else
int arr4[8]={3,0,1,4,5,2,1,0};//用于第五步的循环
int arr5[4]={3,6,7,4};//用于第七、九步的循环
int arr6[12]={3,0,1,2,5,4,7,8,5,2,1,0};//用于第八步的循环
cout<<"输入九个数"<<endl;
if(circle1[j]==i)
break;
while(status[2]==1||status[2]==0)
{
status[circle1[j%8]]=status[circle1[(j+1)%8]];
status[circle1[(j+1)%8]]=0;
j++;
}
}
else if(status[2]==1&&status[4]==0)
cout<<endl;
}
i=3;//空格当前位置
for(j=0;;j++)
if(arr2[j]==i)
break;
// cout<<j;
while(status[1]!=2)
{
status[arr2[j%8]]=status[arr2[(j+1)%8]];
int circle2[4]={1,4,5,2};//用于第一步的循环
int arr1[8]={0,3,6,7,8,5,4,1};//用于第2步的循环
int arr2[8]={1,4,3,6,7,8,5,2};//用于第三步的循环
int arr3[6]={3,6,7,8,5,4};//用于第四、六步的循环
cout<<endl;
}
i=4;
if(status[8]==5)
goto lop9;
for(j=0;;j++)
if(arr5[j]==i)
break;
while(status[4]!=5)
{
status[arr5[j%4]]=status[arr5[(j+1)%4]];
cout<<status[i*3+j]<<" ";
cout<<endl;
}
i=3;//当前空格位置
lop6: for(j=0;;j++)
if(arr3[j]==i)
break;
while(status[5]!=4)
{
status[arr3[j%6]]=status[arr3[(j+1)%6]];
while(status[3]!=0);
//第五步
cout<<"第5步结果:"<<endl;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cout<<endl;
}
i=3;
for(j=0;;j++)
if(arr6[j]==i)
break;
do
{
status[arr6[j%12]]=status[arr6[(j+1)%12]];
status[arr6[(j+1)%12]]=0;
j++;
}
while(status[3]!=0);//第八步
cout<<endl;
}
i=4;//空格当前位置
if(status[2]==3)
goto lop6;
for(j=0;;j++)
if(arr3[j]==i)
break;
while(status[4]!=3)
{
status[arr3[j%6]]=status[arr3[(j+1)%6]];
status[arr2[(j+1)%8]]=0;
j++;
}//第三步
cout<<"第3步结果:"<<endl;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cout<<status[i*3+j]<<" ";