八数码实验报告人工智能课设报告
人工智能实验总结
总结
宽度优先搜索法
在有解的情形总能保证搜索到最短路经，也 就是移动最少步数的路径。但宽度优先搜索法的 最大问题在于搜索的结点数量太多，因为在宽度 优先搜索法中，每一个可能扩展出的结点都是搜 索的对象。随着结点在搜索树上的深度增大，搜 索的结点数会很快增长，并以指数形式扩张，从 而所需的存储空间和搜索花费的时间也会成倍增 长。
1 2
0 1 0 1
0 0 1 1
0 1 1 0
神经网络设计
用两层神经网络来实现，其中隐层为随机 感知器层（net1），神经网络元数目设计为 3，其权值和阈值是随机的，它的输出作为 输出层（分类层）的输入；输出层为感知 器层（net2），其神经元数为1，这里仅对 该层进行训练。
程序运行结果
随机感知器层的权值向量 iw1 = 0.4267 -0.6556 -0.5439 0.9376 -0.1007 -0.2886 随机感知器层的阈值向量 b1 = 0.4074 0.0441 0.8658
运行结果分析
上面实验结果可以看出，城市数目为30的 时候，当迭代次数为100，算法收敛慢，在 迭代次数内最优解没有达到稳定，没有搜 索到最好的解。 迭代次数为200和250的时候，算法基本达 到收敛，最优解在100代以后趋于稳定，表 明搜索到问题的最优解。
运行结果
当城市数目改变的时候： CityNum=50;最大代数gnmax=100;
程序运行结果
第二层感知器层的权值向量和阈值向量 iw2 = -3 -2 2 b2 = 2
人工智能_八数码实验报告【范本模板】
西安郵電大学人工智能实验报告书（三）学院：自动化学院专业：智能科学与技术班级：智能1403姓名：刘忠强时间：2016—3—29一、实验目的1. 熟悉人工智能系统中的问题求解过程；2。
熟悉状态空间的盲目搜索策略;3.掌握盲目收索算法，重点是宽度优先收索和深度优先收索.二、实验算法广度优先收索是一种先生成的节点先扩展的策略。
它的过程是：从初始节点开始逐层向下扩展,再第n层节点还没有完全搜索之前，不进如第n+1层节点.Open表中的节点总是按进入的先后排序，先进入的节点排在前面，够进入的排在后面。
三、程序框图四、实验结果及分析初始状态：目标状态：2 83 2 1 61 6 4 4 0 87 0 5 7 5 3五、源程序及注释＃include <iostream〉#include <ctime>#include 〈vector〉using namespace std；const int ROW = 3;const int COL = 3；const int MAXDISTANCE = 10000;const int MAXNUM = 10000；int abs（int a){if (a>0) return a；else return —a；｝typedef struct _Node{int digit［ROW］［COL］；int dist; // 距离int dep; // 深度int index; // 索引值} Node；Node src， dest；vector〈Node〉 node_v； // 储存节点bool isEmptyOfOPEN(）｛ //判断Open表是否空for （int i = 0； i 〈 node_v.size（)； i++）｛if (node_v[i]。
dist ！= MAXNUM）return false；｝return true；｝bool isEqual(int index, int digit[］[COL］） { //判断节点是否与索引值指向的节点相同for （int i = 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 （int i = 0; i < ROW; i++） {for （int j = 0； j 〈 COL； j++)os <〈 node。
八数码问题
+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步到达
八数码 人工智能实验报告
八数码人工智能实验报告八数码人工智能实验报告引言：八数码是一种经典的数学问题，也是人工智能领域中常用的实验题目之一。
本次实验旨在通过使用搜索算法解决八数码问题，探讨人工智能在解决复杂问题上的应用。
一、问题描述：八数码问题是一种数字排列游戏，使用一个3x3的方格，其中8个方格上各有一个数字，剩下一个方格为空白。
通过移动数字方格，最终将数字按照从小到大的顺序排列，空白方格位于最后一个位置。
例如，初始状态为：1 2 38 47 6 5目标状态为：1 2 34 5 67 8二、算法选择：本次实验采用了A*搜索算法来解决八数码问题。
A*算法是一种启发式搜索算法，通过估计每个搜索节点到达目标状态的代价来进行搜索。
它综合了广度优先搜索和最佳优先搜索的优点，能够高效地找到最优解。
三、实验过程：1. 状态表示：在实验中，我们使用一个3x3的二维数组来表示八数码的状态。
数组中的每个元素代表一个方格的数字，空白方格用0表示。
2. 启发函数：为了评估每个搜索节点到达目标状态的代价，我们需要定义一个启发函数。
本实验中，我们选择了曼哈顿距离作为启发函数。
曼哈顿距离是指每个数字方格与其目标位置之间的水平和垂直距离之和。
3. A*算法：A*算法的核心思想是维护一个优先队列，根据每个搜索节点的估价函数值进行排序。
具体步骤如下：- 将初始状态加入优先队列，并设置初始估价函数值为0。
- 从优先队列中取出估价函数值最小的节点，进行扩展。
- 对于每个扩展节点，计算其估价函数值，并将其加入优先队列。
- 重复上述步骤，直到找到目标状态或者队列为空。
四、实验结果：经过实验，我们发现A*算法能够高效地解决八数码问题。
对于初始状态为随机排列的八数码，A*算法能够在较短的时间内找到最优解。
实验结果表明，A*算法在解决八数码问题上具有较好的性能。
五、实验总结：本次实验通过使用A*搜索算法解决八数码问题，展示了人工智能在解决复杂问题上的应用。
A*算法通过合理的启发函数和优先队列的维护，能够高效地找到最优解。
八数码实验报告人工智能课设报告
学生实验报告实验课名称：人工智能实验名称: 八数码专业名称：计算机科学与技术班级：学号：学生姓名：教师姓名：2010 年10 月20日一．实验内容用OPEN表和CLOSED表解决搜索问题。
二．实验题目采用启发式算法（如A*算法）求解八数码问题。
三．实验要求1.必须使用OPEN表和CLOSED表。
2.明确给出问题描述。
系统初始状态。
目标状态和启发式函数。
3.除了初始状态以外，至少搜索四层。
4.给出解路径（解图）。
四．实验过程①问题：初始状态到目标状态是否可解如何判断？答：实验过程自己给出的初始状态使用A*算法求解，并不是所有的初始状态都可解到达目标状态。
因为八数码问题其实是0~9的一个排列，而排列有奇排列和偶排列，从奇排列不能转化为偶排列或者相反。
例如：函数f(s)表示s前比s 小的数字的数目（s则当f(a8)+f(a7)+……+f(a1)为偶数时才能重排成，所以嘛,上面那个有解的.②问题描述：在3X3的九宫格棋盘上，摆有8个将牌，每一个将牌都刻有1~8数码中的某一个数码。
棋盘中留有一个空格，允许周围的某一个将牌向空格移动，这样通过移动将牌就可以不断地改变将牌的布局。
这种游戏的求解的问题是：给定一种处世的将牌布局或结构和一个目标的布局，问如何移动将牌，实现从从初始状态到目标状态的转变。
下面给出初始状态和目标状态：初始状态：目标状态：评价函数f(n)形式为：f(n)=g(n)+h(n),其中g(n)是节点所处的深度，h(n)是启发式函数，这里启发式函数h(n)表示“不在位”的将牌个数，这时f(n)可估计出通向目标结点的希望的程度。
注意：移动规则为左-→上→右→下。
③搜索过程：如下图-1为八数码问题的搜索树：因此可得解路径：S(4)→B(4)→D(5)→E(5)→I(5)→K(5)→L(5).④得到OPEN表和CLOSED表结论：由以上分析,可以从CLOSED表中可知从初始状态到结束状态的搜索路径为：S0→S2→S5→S9→S11→S12.五、实验体会通过本次实验又将课本内容熟悉了一遍，而且通过互联网了解了更多的关于八数码问题，如读过网上用VC++编写八数码问题的源代码，虽然理解不是很深，但基本思想也是有所体会；同时也对广度优先搜索算法，深度优先算法，双向广度优先算法及A*算法有更深的掌握。
八数码问题人工智能实验报告
基于人工智能的状态空间搜索策略研究——八数码问题求解（一）实验软件或编程语言或其它编程语言（二）实验目的1. 熟悉人工智能系统中的问题求解过程；2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用；3. 熟悉对八数码问题的建模、求解及编程语言的应用。
（三）需要的预备知识1. 熟悉或编程语言或者其它编程语言；2. 熟悉状态空间的宽度优先搜索、深度优先搜索和启发式搜索算法；3. 熟悉计算机语言对常用数据结构如链表、队列等的描述应用；4. 熟悉计算机常用人机接口设计。
（四）实验数据及步骤1. 实验内容八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。
437465图1 八数码问题示意图请任选一种盲目搜索算法（深度优先搜索或宽度优先搜索）或任选一种启发式搜索方法（A 算法或 A* 算法）编程求解八数码问题（初始状态任选），并对实验结果进行分析，得出合理的结论。
2. 实验步骤（1）分析算法基本原理和基本流程；程序采用宽度优先搜索算法，基本流程如下：（2）确定对问题描述的基本数据结构，如 Open 表和 Closed 表等；（3）编写算符运算、目标比较等函数；（4）编写输入、输出接口；（5）全部模块联调；（6）撰写实验报告。
（五）实验报告要求所撰写的实验报告必须包含以下内容：1. 算法基本原理和流程框图；2. 基本数据结构分析和实现；3. 编写程序的各个子模块，按模块编写文档，含每个模块的建立时间、功能、输入输出参数意义和与其它模块联系等；4. 程序运行结果，含使用的搜索算法及搜索路径等；5. 实验结果分析；6. 结论；7. 提供全部源程序及软件的可执行程序。
附：实验报告格式一、实验问题二、实验目的三、实验原理四、程序框图五、实验结果及分析六、结论。
人工智能实验报告,包括八数码问题八皇后问题和tsp问题
八数码问题（一）问题描述在一个3*3的方棋盘上放置着1,2,3,4,5,6,7,8八个数码,每个数码占一格,且有一个空格。
这些数码可以在棋盘上移动，其移动规则是：与空格相邻的数码方格可以移入空格。
现在的问题是：对于指定的初始棋局和目标棋局，给出数码的移动序列。
该问题称八数码难题或者重排九宫问题。
（二）问题分析八数码问题是个典型的状态图搜索问题。
搜索方式有两种基本的方式，即树式搜索和线式搜索。
搜索策略大体有盲目搜索和启发式搜索两大类。
盲目搜索就是无“向导”的搜索，启发式搜索就是有“向导”的搜索。
1、启发式搜索由于时间和空间资源的限制，穷举法只能解决一些状态空间很小的简单问题，而对于那些大状态空间的问题，穷举法就不能胜任，往往会导致“组合爆炸”。
所以引入启发式搜索策略。
启发式搜索就是利用启发性信息进行制导的搜索。
它有利于快速找到问题的解。
由八数码问题的部分状态图可以看出，从初始节点开始，在通向目标节点的路径上，各节点的数码格局同目标节点相比较，其数码不同的位置个数在逐渐减少，最后为零。
所以，这个数码不同的位置个数便是标志一个节点到目标节点距离远近的一个启发性信息，利用这个信息就可以指导搜索。
即可以利用启发信息来扩展节点的选择，减少搜索范围，提高搜索速度。
启发函数设定。
对于八数码问题，可以利用棋局差距作为一个度量。
搜索过程中，差距会逐渐减少，最终为零，为零即搜索完成，得到目标棋局。
（三）数据结构与算法设计该搜索为一个搜索树。
为了简化问题，搜索树节点设计如下：struct Chess//棋盘{int cell[N][N];//数码数组int Value;//评估值Direction BelockDirec;//所屏蔽方向struct Chess * Parent;//父节点};int cell[N][N]; 数码数组：记录棋局数码摆放状态。
int Value; 评估值：记录与目标棋局差距的度量值。
Direction BelockDirec; 所屏蔽方向：一个屏蔽方向，防止回推。
人工智能实验报告八数码
人工智能实验报告八数码
人工智能实验报告：八数码
引言
人工智能（AI）是当今世界上最热门的领域之一，它已经在许多领域取得了巨大的成功，包括医疗保健、金融、交通和娱乐等。
在这篇实验报告中，我们将探讨人工智能在解决八数码问题上的应用。
八数码问题是一个经典的智力游戏，它要求玩家将一个3x3的方格中的数字1-8和一个空白格按照一定的规则进行移动，最终达到特定的排列顺序。
这个问题看似简单，但实际上是一个复杂的组合优化问题，需要大量的搜索和计算才能找到最优解。
实验目的
本实验旨在使用人工智能技术解决八数码问题，通过比较不同算法的表现，评估它们在解决这一问题上的效率和准确性。
实验方法
我们使用了两种经典的人工智能算法来解决八数码问题，分别是深度优先搜索（DFS）和A*搜索算法。
我们编写了相应的程序，并在相同的硬件环境下进行了实验。
实验结果
通过实验我们发现，深度优先搜索算法在解决八数码问题上存在着局部最优解的问题，容易陷入死循环。
而A*搜索算法则能够更快地找到最优解，并且在解决问题时所需的搜索次数更少。
结论
本实验结果表明，A*搜索算法在解决八数码问题上表现更优秀，具有更高的效率和准确性。
这为我们在实际应用中选择合适的人工智能算法提供了重要的参考。
未来展望
随着人工智能技术的不断发展，我们相信在解决类似的组合优化问题上会出现更多更高效的算法。
我们将继续深入研究，探索更多的人工智能算法，并将其应用于更广泛的领域，为人类社会带来更多的便利和创新。
人工智能实验报告-八数码演示程序文件
人工智能实验报告八数码演示程序姓名：学号：所学专业：报告题目：提交日期：计算机科学与技术专业八数码演示程序2010年4月9日八数码演示程序1.问题描述1.1八数码问题的解释八数码问题是人工智能经典难题之一。
问题是在3×3 方格盘上，放有八个数码，剩下一个为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始位置转化为目标位置。
本文介绍用A星算法，采用估计值h（n）（曼哈顿距离）和g(m)(当前深度)的和作为估计函数。
1.2八数码问题的搜索形式描述初始状态：初始状态向量，规定向量中各分量对应的位置，各位置上的初始数字<0，1，3，4，5，6，7，8，2>后继函数：移动规则，按照某条规则移动数字得到的新向量<0，1，3，4，5，6，7，8，9>转移到<4，1，3，0，5，6，7，8，2>目标测试：新向量是否是目标状态，也即为<0，1，2，3，4，5，6，7，8>路径耗散函数：在搜索时，每深入一层则当前步数代价加1，代价总和由当前步数和可能还需要移动的步数之和。
1.3 解决方案介绍首先，A*算法需要个估价(评价)函数:f(x)=g(x)+h(x)g(x)通常表示移动至当前状态需要的步数，h(x)则是启发函数。
在算法进行的时候，我们将对每一个可能移动到的状态做评价，计算其f(x)，然后将其放入一个OPEN数组中，最后我们选取OPEN中f(x)值最小的状态作为下一步，再重复上述过程，因为f(x)值最小的状态意味着它最有可能(不是一定)最接近最终状态。
2.算法介绍2.1 搜索算法一般介绍A*算法是一种启发式搜索算法，是常用的最短路搜寻算法，在游戏领域中有广泛的应用。
所谓启发式算法，它与常规的搜索方法最大的不同是在执行过程中始终有一个提示性的信息在引导着算法的进行，使得我们不断靠近目标而不是盲目的遍历，这个提示信息就是由启发函数产生的，启发函数的好坏将直接影响算法的效率，从几篇文献看来，A*算法和广度优先、深度优先算法相比是有很明显的效率优势的。
人工智能实验报告 八数码问题
实验一 启发式搜索算法姓名：徐维坚 学号：2220103484 日期：2012/6/29一、实验目的：熟练掌握启发式搜索A *算法及其可采纳性。
二、实验内容：使用启发式搜索算法求解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 的定义，并测试使用该估价函数是否使算法失去可采纳性。
三、实验原理：1. 问题描述：八数码问题也称为九宫问题。
在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。
棋盘上还有一个空格（以数字0来表示），与空格相邻的棋子可以移到空格中。
要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
所谓问题的一个状态就是棋子在棋盘上的一种摆法。
解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
2. 原理描述：2.1 有序搜索算法：（1）原理：在搜索过程中，OPEN 表中节点按照其估价函数值以递增顺序排列，选择OPEN 表中具有最小估价函数值的节点作为下一个待扩展的节点，这种搜索方法称为有序搜索。
在本例中，估价函数中的)(n g 取节点深度)(n d ，)(n h 为节点n 的状态与目标状态之间错放的个数，即函数)(n ω。
（2）算法描述：① 把起始节点S 放到OPEN 表中，并计算节点S 的)(S f ；② 如果OPEN 是空表，则失败退出，无解；③ 从OPEN 表中选择一个f 值最小的节点i 。
如果有几个节点值相同，当其中有一个 为目标节点时，则选择此目标节点；否则就选择其中任一个节点作为节点i ；④ 把节点i 从 OPEN 表中移出，并把它放入 CLOSED 的已扩展节点表中；⑤ 如果i 是个目标节点，则成功退出，求得一个解；⑥ 扩展节点i ，生成其全部后继节点。
人工智能A算法八数码报告
人工智能课程设计报告题目：A*算法解决八数码问题专业：计算机软件与理论1．8数码问题1.1问题描述八数码问题是指这样一种游戏：将分别标有数字1，2，3，…，8 的八块正方形数码牌任意地放在一块3×3 的数码盘上。
放牌时要求不能重叠。
于是，在3×3 的数码盘上出现了一个空格。
现在要求按照每次只能将与空格相邻的数码牌与空格交换的原则，不断移动该空格方块以使其和相邻的方块互换，直至达到所定义的目标状态。
空格方块在中间位置时有上、下、左、右4个方向可移动，在四个角落上有2个方向可移动，在其他位置上有3个方向可移动，问题描述如图1-1所示初始状态过渡状态最终状态图1-1 八数码问题执行过程1.2.八数码问题形式化描述初始状态：初始状态向量：规定向量中各分量对应的位置，各位置上的数字。
把3×3的棋盘按从左到右，从上到下的顺序写成一个一维向量。
我们可以设定初始状态：<1,5,2,4,0,3,6,7,8>后继函数：按照某种规则移动数字得到的新向量。
例如：<1,5,2,4,0,3,6,7,8> <1,0,2,4,5,3,6,7,8>目标测试：新向量是都是目标状态。
即<1,2,3,4,5,6,7,8,0>是目标状态？路径耗散函数：每次移动代价为1，每执行一条规则后总代价加1。
1.3解决方案该问题是一个搜索问题。
它是一种状态到另一种状态的变换。
要解决这个问题，必须先把问题转化为数字描述。
由于八数码是一个3*3的矩阵，但在算法中不实用矩阵，而是将这个矩阵转化为一个一维数组，使用这个一维数组来表示八数码，但是移动时要遵守相关规则。
(1)可用如下形式的规则来表示数字通过空格进行移动：<a1,a2,a3,a4,a5,a6,a7,a8,a9>→<b1,b2,b3,b4,b5,b6,b7,b8,b9>(2)共24条移动规则，对应与每个位置的移动规则。
人工智能实验报告 八数码
人工智能实验报告八数码人工智能实验报告八数码引言：人工智能（Artificial Intelligence，简称AI）作为一门前沿的学科，已经在各个领域展现出了巨大的应用潜力。
其中，八数码问题作为一个经典的算法问题，被广泛应用于人工智能领域。
本文将对八数码问题进行实验研究，探讨其在人工智能中的应用。
一、八数码问题的定义八数码问题是指在一个3x3的棋盘上，摆放有1至8这8个数字，其中一个格子为空。
玩家需要通过移动数字，使得棋盘上的数字按照从小到大的顺序排列，空格在最后。
八数码问题可以被抽象为一个搜索问题，即找到从初始状态到目标状态的最短路径。
二、实验方法为了解决八数码问题，我们采用了A*算法作为实验方法。
A*算法是一种启发式搜索算法，通过估计目标状态与当前状态之间的代价函数，选择最优的路径进行搜索。
在本次实验中，我们将使用曼哈顿距离作为代价函数进行搜索。
三、实验结果我们使用Python编程语言实现了八数码问题的求解算法，并进行了多组实验。
实验结果表明，A*算法在解决八数码问题上表现出了较好的效果。
在大部分情况下，A*算法能够在较短的时间内找到最优解。
四、实验讨论尽管A*算法在解决八数码问题上表现出了较好的效果，但我们也发现了一些问题。
首先，A*算法在面对复杂的八数码问题时，搜索时间会显著增加。
其次，A*算法在面对某些特定情况时，可能会陷入局部最优解，无法找到全局最优解。
这些问题需要进一步的研究和改进。
五、应用前景八数码问题作为人工智能领域的经典问题，有着广泛的应用前景。
首先，八数码问题可以被应用于游戏设计中，作为一种智能对手的算法。
其次，八数码问题的解决方法可以被应用于路径规划、图像识别等领域，提高算法的效率和准确性。
六、结论通过本次实验，我们对八数码问题进行了深入的研究和探讨。
A*算法作为一种启发式搜索算法，在解决八数码问题上表现出了较好的效果。
然而，八数码问题仍然存在一些挑战和问题，需要进一步的研究和改进。
人工智能实验报告完整版八数码+验证解读
把数码问题就是把一串数字变成下面这个样子:1 2 38 0 47 6 5实现方法1.过程表示源代码：#include<stdio.h>static int style[9]={1,2,3,6,7,4,5,8,0};//输入的数码//2,5,4,3,0,7,1,8,6 3,2,1,8,0,4,7,6,5 1,0,4,2,7,3,8,5,6 1,0,3,8,2,4,7,6,5static int arrayStep41[6]={5,4,3,6,7,8};//第四步和第六步共用的数组，所以设为全局量static int arrayStep71[4]={3,6,7,4};static int local;//空格的位置int i,j;//所用到的变量int number=0;//记录移动步数void print();void step1();void step2();void step3();void step4();void step5();void step6();void step7();void step8();void step9();void exchange(int x,int y);void judge();void judge()//判断空格位置{number = 0;for(i=0;i<9;i++){if(style[i]==0){local=i;return;}}}void exchange(int x,int y)//交换两个数{int temp;print();temp=style[x];style[x]=style[y];style[y]=temp;local=y;number++;}void step1(){int arrayStep11[5]={3,0,1,2,5};int arrayStep12[6]={6,7,8,5,2,1};if((style[2]!=0)&&style[2]!=1)return;else{if(local==2){if(style[1]==1)exchange(2,5);elseexchange(2,1);return;}else{if(local==4){exchange(4,1);i=2;while(local!=5){exchange(arrayStep11[i],arrayStep11[i+1]);i++;}return;}for(i=0;i<3;i++){if(arrayStep11[i]==local){while(local!=5){exchange(arrayStep11[i],arrayStep11[i+1]);i++;}return;}}for(i=0;i<4;i++){if(arrayStep12[i]==local){while(local!=1){exchange(arrayStep12[i],arrayStep12[i+1]);i++;}return;}}}}return;}void step2(){int arrayStep21[8]={0,3,6,7,8,5,4,1};for(i=0;i<8;i++){if(arrayStep21[i]==local){while(style[0]!=1){exchange(arrayStep21[i%8],arrayStep21[(i+1)%8]);i++;}break;}}}void step3(){int arrayStep31[8]={2,1,4,3,6,7,8,5};for(i=0;i<8;i++){if(arrayStep31[i]==local){while(style[1]!=2){exchange(arrayStep31[i%8],arrayStep31[(i+1)%8]);i++;}break;}}}void step4(){for(i=0;i<6;i++){if(arrayStep41[i]==local){while((style[4]!=3)){exchange(arrayStep41[i%6],arrayStep41[(i+1)%6]);i=(i+1)%6;}while(local!=3){exchange(arrayStep41[i%6],arrayStep41[(i+5)%6]);i=(i+5)%6;}break;}}}void step5(){int arrayStep51[9]={3,0,1,4,5,2,1,0,3};i=0;do{exchange(arrayStep51[i],arrayStep51[i+1]);i++;}while(local!=3);}void step6(){for(i=0;i<6;i++){if(arrayStep41[i]==local){while(style[5]!=4){exchange(arrayStep41[i%6],arrayStep41[(i+1)%6]);i++;}if(local==8)exchange(8,7);break;}}return;}void step7(){for(i=0;i<4;i++){if(arrayStep71[i]==local){while(style[4]!=5){exchange(arrayStep71[i%4],arrayStep71[(i+1)%4]);i=(i+1)%4;}while(local!=3){exchange(arrayStep71[i%4],arrayStep71[(i+3)%4]);i=(i+3)%4;}break;}}}void step8(){int arrayStep81[13]={3,0,1,2,5,4,7,8,5,2,1,0,3};i=0;do{exchange(arrayStep81[i],arrayStep81[i+1]);i++;}}void step9(){for(i=0;i<4;i++){if(arrayStep71[i]==local){while(style[7]!=6){exchange(arrayStep71[i%4],arrayStep71[(i+1)%4]);i=(i+1)%4;}while(local!=4){exchange(arrayStep71[i%4],arrayStep71[(i+3)%4]);i=(i+3)%4;}break;}}}void print(){for(j=0;j<9;j++){if(style[j]==0)printf(" \t");elseprintf("%d\t",style[j]);if((j+1)%3==0)printf("\n");}printf("************ %d ***********\n",number);}void loop(){printf("请输入数码：\n");for(i=0;i<9;i++)scanf("%d",&style[i]);judge();step1();step2();step3();{step4();step5();}step6();if(style[8]!=5){step7();step8();}step9();print();if(!((style[3]==8)&&(style[6]==7)))printf("用书上所给算法来看此数码错误！\n"); }void main(){while(1)loop();}2.深度优先实现/***************说明***********************用宽度优先搜索算法实现八数码问题******************************************/#include<iostream>#include<stdio.h>#include<fstream>#include<stdlib.h>#include "string.h"#include "assert.h"#include "windows.h"using namespace std;int wholeStyle[9] = {2,8,3,1,6,4,7,0,5};int standard1[9] = {1,2,3,8,0,4,7,6,5};int local,i,j;int startKey = 0,endKey = 0,equalKey = 1,tempSpace;struct node *openHead,*open; //open表struct node *closedHead,*closed; //closed表struct node *tempNode; //临时节点struct node *answer; //找到的路径int num = 0;struct node{int style[9];struct node *next;struct node *father;};void updateData() //更新要判断数据{int i;printf("请输入八数码原始状态：\n");for(i = 0;i < 9;i++)scanf("%d",&wholeStyle[i]);printf("请输入八数码最终状态：\n");for(i = 0;i < 9;i++)scanf("%d",&standard1[i]);}void judge1(struct node *head)//判断空格位置{for(i = 0;i < 9;i++){if(head->style[i] == 0){local = i;return;}}}int judge2(struct node *head) //判断是否与标准八数码相等，不相等返回值为0 {for(i = 0;i < 9;i++){if(head->style[i] != standard1[i]){if((i == 3)&&(head->style[3] == standard1[6]));else if((i == 6)&&(head->style[6] == standard1[3]));elsereturn 0;}}return 1;}void judge3() //判断新生成的八数码是否就是最终状态或者在open、closed表中出现{if(judge2(tempNode))endKey = 1;else{while(openHead->next->next->style[0] != 9){for(i = 0;i < 9;i++){if(openHead->next->next->style[i] != tempNode->style[i]){equalKey = 1;break;}elseequalKey = 0;}if(equalKey)//不相等openHead = openHead->next;elsebreak;}openHead = open->next;if(equalKey)//不相等{while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i++){if(closedHead->next->style[i] != tempNode->style[i]){equalKey = 1;break;}elseequalKey = 0;}if(!equalKey)//相等break;elseclosedHead = closedHead->next;}closedHead = closed->next;}if(equalKey)//不相等{open->next = tempNode;tempNode->next = openHead;tempNode->father = openHead->next;open = open->next;}}}void print(struct node *temp) //输出八数码表{for(j = 0;j < 9;j++){if(temp->style[j] == 0)printf(" \t");elseprintf("%d\t",temp->style[j]);if((j + 1) % 3 == 0)printf("\n");}}void write2txt(){ofstream out("F:\\out_details.txt",ios::app);if( out.fail() ){cerr<<"未找到文件"<<endl;}out<<" 第"<<++num<<"步\n";out<<"open table：\n";while(openHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<openHead->next->style[i]<<"\t";if((i+1) % 3 == 0)out<<"\n";}out<<"\n";openHead = openHead->next;}openHead = openHead->next;out<<"*********************\n";out<<"closed table：\n";while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<closedHead->next->style[i]<<"\t";if((i + 1) % 3 ==0)out<<"\n";}out<<"\n";closedHead = closedHead->next;}closedHead = closedHead->next;out<<"-----------------------------------\n";out.close();}void main(){//updateData();//输入八数码数据for(i = 0;i < 9;i++) //判断初始状态是否已经为最终状态{if(wholeStyle[i] == standard1[i]);else{if((i == 3)&&(wholeStyle[i] == standard1[6]));else if((i == 6)&&(wholeStyle[i] == standard1[3]));else{startKey = 1;break;}}}if(!startKey){printf("不用判断！\n");return;}printf("要判断！\n");openHead = new node();open = new node();openHead->style[0] = 9;openHead->next = open;for(i = 0;i < 9;i++)open->style[i] = wholeStyle[i];open->next = openHead;open->father = openHead;closedHead = new node();closed = new node();closedHead->style[0] = 9;closedHead->next = closedHead;closed = closedHead;while(open->style[0] != 9)//当open表不为空时一直循环{judge1(openHead->next);if(local % 3 > 0)//右移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local - 1];tempNode->style[local - 1] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local > 2)//下移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local - 3];tempNode->style[local - 3] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local % 3 < 2)//左移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local + 1];tempNode->style[local + 1] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local < 6)//上移{equalKey = 1;tempNode = new node();//tempNode = malloc(sizeof(struct node));for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local + 3];tempNode->style[local + 3] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;closed->next = openHead->next; //把open的标头添加到closed表中openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;write2txt();}open->next = tempNode;//把找到的新节点添加到open表中tempNode->next = openHead;tempNode->father = openHead->next;open = open->next;closed->next = openHead->next; //把open的标头添加到closed表中openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;write2txt();answer = new node();tempNode = new node();tempNode = open;while(tempNode->style[0] != 9)//将结果路径存于answer{answer = tempNode;tempNode = tempNode->father;tempNode->next = answer;}num = 0;while(answer->next->style[0] != 9)//输出answer{printf("***********第%d步***********\n",num++);print(answer);answer = answer->next;printf("\n");}printf("***********第%d步***********\n",num++);print(answer);if(answer->style[3] != standard1[3])printf("\n!!输入的八数码不合法，不能从初始状态到最终状态\n\n\n\n");return;}3.宽度优先：/***************说明***********************用宽度优先搜索算法实现八数码问题******************************************/#include<iostream>#include<stdio.h>#include<fstream>#include<stdlib.h>#include "string.h"#include "assert.h"#include "windows.h"using namespace std;int wholeStyle[9] = {2,8,3,1,6,4,7,0,5};int standard1[9] = {1,2,3,8,0,4,7,6,5};int local,i,j;int startKey = 0,endKey = 0,equalKey = 1,tempSpace; struct node *openHead,*open; //open表struct node *closedHead,*closed; //closed表struct node *tempNode; //临时节点struct node *answer; //找到的路径int num = 0;struct node{int style[9];struct node *next;struct node *father;};void updateData() //更新要判断数据{int i;printf("请输入八数码原始状态：\n");for(i = 0;i < 9;i++)scanf("%d",&wholeStyle[i]);printf("请输入八数码最终状态：\n");for(i = 0;i < 9;i++)scanf("%d",&standard1[i]);}void judge1(struct node *head)//判断空格位置{for(i = 0;i < 9;i++){if(head->style[i] == 0){local = i;return;}}}int judge2(struct node *head) //判断是否与标准八数码相等，不相等返回值为0{for(i = 0;i < 9;i++){if(head->style[i] != standard1[i]){if((i == 3)&&(head->style[3] == standard1[6]));else if((i == 6)&&(head->style[6] == standard1[3]));elsereturn 0;}}return 1;}void judge3() //判断新生成的八数码是否就是最终状态或者在open、closed表中出现{if(judge2(tempNode))endKey = 1;else{while(openHead->next->next->style[0] != 9){for(i = 0;i < 9;i++){if(openHead->next->next->style[i] != tempNode->style[i]){equalKey = 1;break;}elseequalKey = 0;}if(equalKey)//不相等openHead = openHead->next;elsebreak;}openHead = open->next;if(equalKey)//不相等{while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i++){if(closedHead->next->style[i] != tempNode->style[i]){equalKey = 1;break;}elseequalKey = 0;}if(!equalKey)//相等break;elseclosedHead = closedHead->next;}closedHead = closed->next;}if(equalKey)//不相等{open->next = tempNode;tempNode->next = openHead;tempNode->father = openHead->next;open = open->next;}}}void print(struct node *temp) //输出八数码表{for(j = 0;j < 9;j++){if(temp->style[j] == 0)printf(" \t");elseprintf("%d\t",temp->style[j]);if((j + 1) % 3 == 0)printf("\n");}}void write2txt(){ofstream out("F:\\out_details.txt",ios::app);if( out.fail() ){cerr<<"未找到文件"<<endl;}out<<" 第"<<++num<<"步\n";out<<"open table：\n";while(openHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<openHead->next->style[i]<<"\t";if((i+1) % 3 == 0)out<<"\n";}out<<"\n";openHead = openHead->next;}openHead = openHead->next;out<<"*********************\n";out<<"closed table：\n";while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<closedHead->next->style[i]<<"\t";if((i + 1) % 3 ==0)out<<"\n";}out<<"\n";closedHead = closedHead->next;}closedHead = closedHead->next;out<<"-----------------------------------\n";out.close();}void main(){//updateData();//输入八数码数据for(i = 0;i < 9;i++) //判断初始状态是否已经为最终状态{if(wholeStyle[i] == standard1[i]);else{if((i == 3)&&(wholeStyle[i] == standard1[6]));else if((i == 6)&&(wholeStyle[i] == standard1[3]));else{startKey = 1;break;}}}if(!startKey){printf("不用判断！\n");return;}printf("要判断！\n");openHead = new node();open = new node();openHead->style[0] = 9;openHead->next = open;for(i = 0;i < 9;i++)open->style[i] = wholeStyle[i];open->next = openHead;open->father = openHead;closedHead = new node();closed = new node();closedHead->style[0] = 9;closedHead->next = closedHead;closed = closedHead;while(open->style[0] != 9)//当open表不为空时一直循环{judge1(openHead->next);if(local % 3 > 0)//右移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local - 1];tempNode->style[local - 1] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local > 2)//下移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local - 3];tempNode->style[local - 3] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local % 3 < 2)//左移{equalKey = 1;tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local + 1];tempNode->style[local + 1] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;if(local < 6)//上移{equalKey = 1;tempNode = new node();//tempNode = malloc(sizeof(struct node));for(i = 0;i < 9;i++)tempNode->style[i] = openHead->next->style[i];tempSpace = tempNode->style[local + 3];tempNode->style[local + 3] = tempNode->style[local];tempNode->style[local] = tempSpace;judge3();}if(endKey)break;closed->next = openHead->next; //把open的标头添加到closed表中openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;write2txt();}open->next = tempNode;//把找到的新节点添加到open表中tempNode->next = openHead;tempNode->father = openHead->next;open = open->next;closed->next = openHead->next; //把open的标头添加到closed表中openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;write2txt();answer = new node();tempNode = new node();tempNode = open;while(tempNode->style[0] != 9)//将结果路径存于answer{answer = tempNode;tempNode = tempNode->father;tempNode->next = answer;}num = 0;while(answer->next->style[0] != 9)//输出answer{printf("***********第%d步***********\n",num++);print(answer);answer = answer->next;printf("\n");}printf("***********第%d步***********\n",num++);print(answer);if(answer->style[3] != standard1[3])printf("\n!!输入的八数码不合法，不能从初始状态到最终状态\n\n\n\n");return;}4.A算法/***************说明************************* A算法实现八数码问题********************************************/#include<iostream>#include<fstream>#include<iomanip>using namespace std;void print(struct node *temp);int wholeStyle[9] = {2,8,3,1,6,4,7,0,5};int standard1[9] = {1,2,3,8,0,4,7,6,5};int local,i,j;int tempSpace;struct node *openHead,*open; //open表struct node *closedHead,*closed; //closed表struct node *tempNode; //临时节点struct node *answer; //找到的路径int num = 0;bool endKey;struct node{int depth;int judgement_based;int style[9];struct node *next;struct node *father;};void updateData() //更新要判断数据{int i;cout<<"请输入八数码原始状态："<<endl;for(i = 0;i < 9;i++)cin>>wholeStyle[i];cout<<"请输入八数码最终状态："<<endl;for(i = 0;i < 9;i++)cin>>standard1[i];}int judge1(struct node *head)//判断空格位置{for(i = 0;i < 9;i++){if(head->style[i] == 0)return i;}}int evaluation_function(struct node *head) //计算不在正确位置的点的个数{int not_correct_position = 0;for(i = 0;i < 9;i++)if((head->style[i] != 0)&&(head->style[i] != standard1[i]))not_correct_position++;return not_correct_position;}void print(struct node *temp) //输出八数码表{for(j = 0;j < 9;j++){if(temp->style[j] == 0)cout<<" \t";elsecout<<temp->style[j]<<"\t";if((j + 1) % 3 == 0)cout<<endl;}}void write2txt() //将过程记录到文本文档中{ofstream out("F:\\out_details4.txt",ios::app);if( out.fail() ){cerr<<"未找到文件"<<endl;}out<<" 第"<<++num<<"步\n";out<<"open table：\n";while(openHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<openHead->next->style[i]<<"\t";if((i+1) % 3 == 0)out<<"\n";}out<<"估值：";out<<openHead->next->judgement_based<<"\n";openHead = openHead->next;}openHead = openHead->next;out<<"*********************\n";out<<"closed table：\n";while(closedHead->next->style[0] != 9){for(i = 0;i < 9;i ++){out<<closedHead->next->style[i]<<"\t";if((i + 1) % 3 ==0)out<<"\n";}out<<"深度："<<closedHead->next->depth<<" 估值："<<closedHead->next->judgement_based<<"\n";closedHead = closedHead->next;}closedHead = closedHead->next;out<<"-----------------------------------\n";out.close();}void basic_exchange_oper() //每一次基本的交换都要进行的动作{if(judge1(tempNode) != judge1(closed->father))//当新生成节点的空格位置与closed父亲节点的空格位置不相等{tempNode->father = closed; //新生成节点的指向它的父亲节点tempNode->depth = closed->depth + 1;//深度加1tempNode->judgement_based = evaluation_function(tempNode) + tempNode->depth;//计算估值while(openHead->next->style[0] != 9){if(tempNode->judgement_based > openHead->next->judgement_based){openHead = openHead->next;}else{tempNode->next = openHead->next;openHead->next = tempNode;openHead = open->next;return;}}//插入的值比最后一个还大进行下面的操作openHead = open->next;//先恢复表头否则Head指向为最后一个open->next = tempNode;tempNode->next = openHead;open = open->next;return;}}void main(){//updateData();//输入八数码数据openHead = new node(); //初始化open表open = new node();openHead->style[0] = 9;openHead->next = open;for(i = 0;i < 9;i++)open->style[i] = wholeStyle[i];open->next = openHead;open->father = openHead;open->depth = 0;open->judgement_based = evaluation_function(open) + open->depth;//这行可以不写closedHead = new node(); //初始化closed表closed = new node();closedHead->style[0] = 9;closedHead->next = closedHead;closed = closedHead;int min_judgement1 = open->judgement_based;while(open->style[0] != 9)//当open表不为空时一直循环{//updateData();//输入八数码数据write2txt();closed->next = openHead->next; //把open表中第一组八数码移到closed表中openHead->next = openHead->next->next;closed = closed->next;closed->next = closedHead;if(openHead->next->style[0] == 9)//如果是第一次则open暂时指向openHead open = openHead;if(closed->judgement_based == closed->depth)//判断新移进closed表中的八数码的f 值是否等于它的层数{cout<<"succeed!"<<endl;write2txt();answer = new node();while(closed->style[0] != 9) //将结果存于answer表中{answer = closed;closed = closed->father;closed->next = answer;}num = 0;while(answer->style[0] != 9) //控制台显示步骤{cout<<"******第"<<num++<<"步***********\n";print(answer);cout<<endl;answer = answer->next;}return;}else //如果closed表末的八数码是最终状态则拓展新的八数码{local = judge1(closed);if(local % 3 > 0)//右移{tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = closed->style[i];tempSpace = tempNode->style[local - 1];tempNode->style[local - 1] = tempNode->style[local];tempNode->style[local] = tempSpace;basic_exchange_oper();}if(local < 6)//上移{tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = closed->style[i];tempSpace = tempNode->style[local + 3];tempNode->style[local + 3] = tempNode->style[local];tempNode->style[local] = tempSpace;basic_exchange_oper();}if(local > 2)//下移{tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = closed->style[i];tempSpace = tempNode->style[local - 3];tempNode->style[local - 3] = tempNode->style[local];tempNode->style[local] = tempSpace;basic_exchange_oper();}if(local % 3 < 2)//左移{tempNode = new node();for(i = 0;i < 9;i++)tempNode->style[i] = closed->style[i];tempSpace = tempNode->style[local + 1];tempNode->style[local + 1] = tempNode->style[local];tempNode->style[local] = tempSpace;basic_exchange_oper();}}}cout<<"false!"<<endl;}神经网络实验群神经网络实验一、实验目的：理解反向传播网络的结构和原理，掌握反向传播算法对神经元的训练过程，了解反向传播公式。
人工智能作业报告
极小极大算法描述如下：
• 1. 以棋局为空为根节点，以1步后的棋局节点的为子节点，广度优先生成一棵博弈树。然后从树根开始轮流给 每层结点赋予MAX和MIN的称号。（此处限定博弈树的深度为3，即只分析双方各下一子的情况。）下棋的一 方是人（记为“MAX"，执棋子“X”），另一方是计算机（记为”MIN“，执棋子“O”）
每一个节点都会由 alpha 和 beta 两个值来确定一个范围 [alpha, beta]，alpha 值代表的是下界，beta 代表的是上界。每 搜索一个子节点，都会按规则对范围进行修正。
Max 节点可以修改 alpha 值，min 节点修改 beta 值。
如果出现了 beta <= alpha 的情况（上界，则不用搜索更多的子树了，未搜索的这部分子树将被忽略，这个操作就被称作 剪枝（pruning）
• 分治递归问题详细分解： • （1）n == 1 • 第1次 1号盘 A---->C count = 1 次 • (2) n == 2 • 第1次 1号盘 A---->B • 第2次 2号盘 A---->C • 第3次 1号盘 B---->C count = 3 次
• （3）n == 3
• 第1次 1号盘 A---->C
设：正方形代表自己（A），圆代表对手（B），节点的每个孩子节点代表一个候选方案
Max 节点：图中的正方形节点，对应于我的回合，它会选取所有子节点中的最大值 作为自身的值 Min 节点：图中的圆形节点，对应于对手的回合，它会选取所有子节点中的最小值 作为自身的值
先定义一个 Node 类，constructor 如下： constructor(data, type, depth) {
八数码问题,实验报告
八数码问题,实验报告八数码实验报告利用人工智能技术解决八数码游戏问题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 的扩展节点表中。
武汉理工大学人功智能概论八数码实验报告
武汉理工大学学生实验报告书实验课程名称人工智能概论B 实验名称八数码问题开课学院计算机科学与技术学院指导老师姓名学生姓名学号学生专业班级2016 —2017 学年第一学期一、实验要求及问题描述采取分组形式，2人一组，一人使用盲目搜索中的宽度优先搜索算法，另一人使用启发式搜索中的全局择优搜索或A*算法。
每组提交一份大作业报告，该报告包括设计、实现、测试、实验对比结果分析、结论、个人体会与总结。
提交截止时间：2016.11.18对任意的八数码问题，给出求解结果。
例如：对于如下具体八数码问题：⇨通过设计启发函数，编程实现求解过程，如果问题有解，给出数码移动过程，否则，报告问题无解。
250 123873 804641 765二、实验原理2.1 状态空间表示1、建立只有初始节点S0的搜索图，并将S放入OPEN表中；2、建立CLOSE表并置空；3、对OPEN表进行判断，若OPEN表为空，则无解；4、将OPEN表中的第一个节点移出，放入CLOSE表中，记为节点n；5、判断节点n是否为目标节点。
是，则有解，解为沿n到S的路径，否，则进行步骤6；6、由节点n生成一组不是n的祖先的后继节点，记为集合P，将P中节点作为n的后继加入搜索图；7、对于在OPEN表和CLOSE表中没有出现过的集合P中的节点，设置指向节点n的指针，把这些节点放入OPEN表中；对于在OPEN表和CLOSE表中已经出现过的P中的节点，确定是否修改指向父节点的指针；8、重拍OPEN表节点顺序；9、转到步骤3。
2.2 数据结构设计//宽度优先搜索中，八数码地图节点结构体struct EightDigit{int Cube[3][3];Direction LastDirection;struct EightDigit *Parent;};//全局择优搜索中，八数码节点结构体struct node{int index;//结点序号int p_index;//父结点序号int matrix[3][3];// 八数码状态int h_function;//启发式函数值};node open[SIZE]; //存放已经生成的未考察的节点node closed[SIZE]; //存放已经考察过得节点2.3 启发式函数与相关算法//计算节点启发式函数值int arouse(int a[][3]){int num=0;int i,j;for(i=0;i<3;i++){for(j=0;j<3;j++){if(a[i][j]==end[i][j]){num++;}}}return 9-num;}//空白节点移动算法int location = locate(now, 0);int i, j;i = location / 3;j = location % 3;copy_matrix(extend, now);if (i > 0) //空格上移{int *p = &extend[i][j];int *q = &extend[i - 1][j];exchange(p, q);if (judge()){inopen(extend);}}copy_matrix(extend, now);if (i < 2) //空格下移{exchange(&extend[i][j], &extend[i + 1][j]);if (judge()){inopen(extend);}}copy_matrix(extend, now);if (j > 0) //空格左移{exchange(&extend[i][j], &extend[i][j - 1]);if (judge()){inopen(extend);}}copy_matrix(extend, now);if (j < 2) //空格右移{exchange(&extend[i][j], &extend[i][j + 1]);if (judge()){inopen(extend);}}2.3 广度优先搜索算法1、把起始节点放到OPEN表中(如果该起始节点为一目标节点，则求得一个解答)；2、如果OPEN是个空表，则没有解，失败退出；否则继续；3、把第一个节点(节点n)从OPEN表移出，并把它放入CLOSE的扩展节点表中；4、扩展节点n。
人工智能实验报告-八数码（五篇模版）
人工智能实验报告-八数码（五篇模版）第一篇：人工智能实验报告-八数码《人工智能》实验一题目实验一启发式搜索算法1.实验内容：使用启发式搜索算法求解8数码问题。
⑴ 编制程序实现求解8数码问题A*算法，采用估价函数⎧⎪w(n)，f(n)=d(n)+⎨pn⎪⎩()其中：d(n)是搜索树中结点n的深度；w(n)为结点n的数据库中错放的棋子个数；p(n)为结点n的数据库中每个棋子与其目标位置之间的距离总和。
⑵ 分析上述⑴中两种估价函数求解8数码问题的效率差别，给出一个是p(n)的上界的h(n)的定义，并测试使用该估价函数是否使算法失去可采纳性。
2.实验目的熟练掌握启发式搜索A算法及其可采纳性。
3.数据结构与算法设计该搜索为一个搜索树。
为了简化问题，搜索树节点设计如下：typedef struct Node//棋盘 {//节点结构体int data[9];double f,g;struct Node * parent;//父节点}Node,*Lnode;int data[9];数码数组：记录棋局数码摆放状态。
struct Chess * Parent;父节点：指向父亲节点。
下一步可以通过启发搜索算法构造搜索树。
1、局部搜索树样例：*2、搜索过程搜索采用广度搜索方式，利用待处理队列辅助，逐层搜索（跳过劣质节点）。
搜索过程如下：（1）、把原棋盘压入队列；（2）、从棋盘取出一个节点；（3）、判断棋盘估价值，为零则表示搜索完成，退出搜索；（4）、扩展子节点，即从上下左右四个方向移动棋盘，生成相应子棋盘；（5）、对子节点作评估，是否为优越节点（子节点估价值小于或等于父节点则为优越节点），是则把子棋盘压入队列，否则抛弃；（5）、跳到步骤（2）；3、算法的评价完全能解决简单的八数码问题，但对于复杂的八数码问题还是无能为力。
现存在的一些优缺点。
1、可以改变数码规模（N），来扩展成N*N的棋盘，即扩展为N 数码问题的求解过程。
人工智能实验设计报告
人工智能九宫格重移——搜索成员：赵春杰 2009210665羊森 2009210653黄鑫 2009210周成兵 2009210664王素娟 20092106441.问题描述：八数码问题也称为九宫问题。
在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。
棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。
要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。
所谓问题的一个状态就是棋子在棋盘上的一种摆法。
棋子移动后，状态就会发生改变。
解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
2.九宫重移有无答案检查（逆序数）我们把每个9宫格横向展开，如第一个123456789，我们把左边数大于右边数的组数称为这个九宫格的逆序数，显然123456789的逆序数为0；考虑横向平移，那么逆序数的增量为2或0或-2；纵向平移，逆序数的增量为4或0或-4；但147258369的逆序数为奇数。
所以147258369是无解的情况。
由此也可以类推当将9宫格展开后，如果数据序列的逆序数为奇数，则此数据序列对应的九宫格是无解的。
3.BFS算法队列： Queue open = new Queue();存放待扩展的节点List： List<Bfstr> closed = new List<Bfstr>();存放已被扩展过的节点ArrayList map = new ArrayList();//存放答案HashTale： Hashtable table = new Hashtable();构造哈希表以方便查找3.1．BFS算法介绍广度优先搜索算法BFS基本思想：从图中某顶点v出发，逐层对节点进行拓展，并考察是否为目标节点，在第n层节点没有全部扩展并考察前，不对第n+1层节点进行扩展。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
学生实验报告
实验课名称：人工智能
实验名称: 八数码
专业名称：计算机科学与技术
班级：
学号：
学生姓名：
教师姓名：
2010 年10 月20日
一．实验内容
用OPEN表和CLOSED表解决搜索问题。
二．实验题目
采用启发式算法（如A*算法）求解八数码问题。
三．实验要求
1.必须使用OPEN表和CLOSED表。
2.明确给出问题描述。
系统初始状态。
目标状态和启发式函数。
3.除了初始状态以外，至少搜索四层。
4.给出解路径（解图）。
四．实验过程
①问题：初始状态到目标状态是否可解如何判断？
答：实验过程自己给出的初始状态使用A*算法求解，并不是所有的初始状态都可解到达目标状态。
因为八数码问题其实是0~9的一个排列，而排列有奇排列和偶排列，从奇排列不能转化为偶排列或者相反。
例如：函数f(s)表示s前比s 小的数字的数目（s
则当f(a8)+f(a7)+……+f(a1)为偶数时才能重排成，所以嘛,上面那个有解的.
②问题描述：
在3X3的九宫格棋盘上，摆有8个将牌，每一个将牌都刻有1~8数码中的某一个数码。
棋盘中留有一个空格，允许周围的某一个将牌向空格移动，这样通过移动将牌就可以不断地改变将牌的布局。
这种游戏的求解的问题是：给定一种处
世的将牌布局或结构和一个目标的布局，问如何移动将牌，实现从从初始状态到目标状态的转变。
下面给出初始状态和目标状态：
初始状态：Array
目标状态：
评价函数f(n)形式为：f(n)=g(n)+h(n),其中g(n)是节点所处的深度，
h(n)是启发式函数，这里启发式函数h(n)表示“不在位”的将牌个数，这时f(n)
注意：移动规则为左-→上→右→下。
③搜索过程：
因此可得解路径：S(4)→B(4)→D(5)→E(5)→I(5)→K(5)→L(5).
④得到OPEN表和CLOSED表
OPEN表
结论：由以上分析,可以从CLOSED表中可知从初始状态到结束状态的搜索路径为：
S0→S2→S5→S9→S11→S12.
五、实验体会
通过本次实验又将课本内容熟悉了一遍，而且通过互联网了解了更多的关于八数码问题，如读过网上用VC++编写八数码问题的源代码，虽然理解不是很深，但基本思想也是有所体会；同时也对广度优先搜索算法，深度优先算法，双向广度优先算法及A*算法有更深的掌握。