重排九宫实验报告
1C#九宫格游戏报告
1
一 实验目的
1. 熟悉 C#的基础操作。 2. 通过程序掌握 C#的操作环境。 3. 学会做好 C#的简单程序
二 实验内容
本程序通过VS2010建立窗体应用程序， 通过控件建立九宫格游戏窗口:
开始时 1-9 格黄橘两色随机分布，按动一个键，周围颜色会转换为相 反色，使 5 键为黄色，其余键为橘色，则游戏过关，具体规则如下： 1. 按动 1 键，则 1，2，4，5 键颜色变反；按动 3，7，9 键同理。 2. 按动 2 键，则 1，2，3 键颜色变反；按动 4，6，8 键同理。 3. 按动 5 键，则 2，4，5，6，8 键颜色变反。
2
当成功后游戏停止。 本游戏中预先设置按钮颜色以便更快达到游戏成功， 能用来检验游戏 的可操作性。
三 设计思路
本实验在 Microsoft Visual Studio 2010 环境中运行，建立相 关控件，游戏时使按键数字参与内部函数的计算，当按键颜色符合时 游戏成功并停止记时。另外设置开始，暂停，退出，清空，帮助键以 供用户更好操作，详情请查看代码。
namespace cs_nineplay
3
{ public partial class Form1 : Form { public Form1() { InitializeComponent(); } Color OnColor = Color.Coral;//橘色变量 Color OffColor = Color.Yellow;//黄色变量 int seconds1,seconds2=999;//当前时间和上一次记录的事件(开始时默认为999) int count1,count2=999;//同理 int[,] ChangeCells ={{-1,-1,-1,-1,-1}, {1,2,4,5,-1}, {2,1,3,-1,-1}, {3,2,5,6,-1}, {4,1,7,-1,-1}, {5,2,4,6,8}, {6,3,9,-1,-1}, {7,4,5,8,-1}, {8,7,9,-1,-1}, {9,5,6,8,-1} };//用于规则变化 Button[] Buttons = new Button[10]; int num = 0;//当前记录的项数 struct TM//记录的时间的次数的结构体 { public int Time, Times; } TM[] tm = new TM[100];//记?录? private void Button_Click(object sender, EventArgs e) { Button btnHit = (Button)sender;//把当前按钮赋给btnHit int No = int.Parse(btnHit.Text);//取当前按钮的数字 for (int i = 0; i < 5; i++) { int X = ChangeCells[No, i]; if (X != -1)//改变按钮相关颜色 { if (Buttons[X].BackColor == OffColor) Buttons[X].BackColor = OnColor; else Buttons[X].BackColor = OffColor; } }
重排九宫格
重排九宫格问题一．问题描述在3*3的方格棋盘上放置分别标有数字1,2,3,4,5,6,7,8的8张牌，初始状态为s0，目标状态为sg，可使用的算符有空格左移，空格上移，空格右移和空格下移，即它们只允许把位于空格左，上，右，下边的牌移入空格。
要求寻找从初始状态到目的状态的路径。
二．算法描述（1）把初始节点S0放入OPEN表。
（2）如果OPEN表为空，则问题无解，退出。
（3）把OPEN表的第一个节点取出放入CLOSE表（记为节点n）。
（4）考察节点n是否为目标节点。
若是，则求得了问题的解，退出。
（5）若节点n不可扩展，则转第2步。
（6）扩展节点n，将其子节点放入OPEN表的尾部，并为每一个子节点都配置指向父节点的指针，然后转第2步。
三.实验结果四.实验结果分析应用广度优先搜索可得到如上图所示的从初始状态到目标状态的路径。
广度优先搜索盲目性较大，当目标节点距初始节点较远时将会产生许多无用节点，搜索效率低。
但只要问题有解，用广度优先搜索总可以得到解，而且得到的是路径最短的解。
五．源代码#include <iostream>using namespace std;#include "classes.h"char element::ebegin[3][3] = {{2,8,3},{1,0,4},{7,6,5}};char element::dest[3][3] = {{1,2,3},{8,0,4},{7,6,5}};double element::k = 1; // if you change the k val, you may get different result.int main() {list<element> open, close; // these are two list that holds the tree node.element ebegin(element::ebegin);mygraph G(&ebegin);// step 1open.pushtop(&ebegin);//G.add(&ebegin);--> the construction function did it very well.while(1){// step 2if (open.getnum() == 0) {cout<<"This question has no solution."<<endl;break;}/*if (close.getnum()>362880){cout<< "out of bound error"<<endl;break;}*///cout<<open.getnum()<<" : "<<close.getnum()<<endl;// step 3element * n;close.pushend(n = open.pop());// step 4if (element::reach(n)){cout<<"solution got:";G.drawtree(n);cout<<"Total steps:"<<n->layer<<endl;break;}//step 5element * M[4];// extend the nodeM[0] = n->goup();M[1] = n->godown();M[2] = n->goleft();M[3] = n->goright();int i;for (i = 0; i < 4 ; i++) {if (M[i] == NULL) continue;if (!G.exist(M[i])){// aG.add(M[i],n);//M[i]->draw();if (!open.exist(M[i]) && !close.exist(M[i]))open.pushbyforder(M[i]);}else{// b & cG.changeparent(M[i], n);}}// 7 order has beeen down in inserting.// 8 when we reached here, we will go to the front.}system("pause");return 0;}classes.hstruct point {int x;int y;point (int px, int py){x = px; y = py;}};class element {public:char m[3][3];static char dest[3][3];static char ebegin[3][3];int layer;static double k;int f_val;element(char s[3][3], int l = 0) {layer = l + 1;for (int i = 0; i < 3 ; i++) {for(int j = 0; j < 3; j++) {m[i][j] = s[i][j];}}this->f();}point getpos(){for (int i = 0; i < 3 ; i++) {for(int j = 0; j < 3; j++) {if (m[i][j] == 0)return point(i, j);}}system("echo unable &pause");}int f(){int g = 0;for(int i = 0; i < 3; i++) {for (int j = 0; j < 3; j++) {if (m[i][j] == dest[i][j]) {g += 0;} else {g += 1;}}}f_val = (int)(layer + k * g);return f_val;}element * goup(){point p = this->getpos();if (p.x > 0){element* pnew = new element(m, layer);pnew->m[p.x][p.y] = pnew->m[p.x - 1][p.y];pnew->m[p.x - 1][p.y] = 0;return pnew;}return NULL;}element * godown(){point p = this->getpos();if (p.x < 2){element* pnew = new element(m, layer);pnew->m[p.x][p.y] = pnew->m[p.x + 1][p.y];pnew->m[p.x + 1][p.y] = 0;return pnew;}return NULL;}element * goleft(){point p = this->getpos();if (p.y > 0){element* pnew = new element(m, layer);pnew->m[p.x][p.y] = pnew->m[p.x][p.y - 1];pnew->m[p.x][p.y - 1] = 0;return pnew;}return NULL;}element * goright(){point p = this->getpos();if (p.y < 2){element* pnew = new element(m, layer);pnew->m[p.x][p.y] = pnew->m[p.x][p.y + 1];pnew->m[p.x][p.y + 1] = 0;return pnew;return NULL;}static bool reach(element * p){for(int i = 0; i < 3; i++) {for(int j = 0; j < 3; j++) {if (p->m[i][j] != dest[i][j])return false;}}return true;}void draw(){cout<<endl;for (int i = 0; i < 3 ; i++) {cout<<'|';for(int j = 0; j < 3; j++) {cout<<(int)m[i][j]<<' ';}cout<<'|'<<endl;}}bool equals(const element *p){for(int i = 0; i < 3; i++) {for(int j = 0; j < 3; j++) {if (p->m[i][j] != this->m[i][j])return false;}}return true;}};template <class T>class list{struct node {T * ptr;node * next;};node * base; // stack base pointer node * top; // stack top pointerint m_num;public:m_num = 0; base = top = NULL;}bool pushtop(T * tp) {if (base == NULL) {base = top = (node *)malloc(sizeof(node));base->next = NULL;} else {node * tmp;tmp = (node *)malloc(sizeof(node));tmp->next = top;top = tmp;}top->ptr = tp;m_num++;return true;}bool pushbyforder(T* tp){if (base == NULL) {base = top = (node *)malloc(sizeof(node));base->next = NULL;top->ptr = tp;} else {node * tmp, *find = top;tmp = (node *)malloc(sizeof(node));tmp->ptr = tp;while (find != NULL) {if (tmp->ptr->f_val < find->ptr->f_val) {tmp->next = find->next;find->next = tmp;if (find == top) {top = tmp;}break;}find = find->next;}if (find == NULL){base->next = tmp;tmp->next = NULL;base = tmp;}}m_num++;return true;}bool pushend(T * p) {if (base == NULL) {base = top = (node *)malloc(sizeof(node));base->next = NULL;} else {node * tmp;tmp = (node *)malloc(sizeof(node));base->next = tmp;tmp->next = NULL;base = tmp;}base->ptr = p;m_num++;return true;}T * pop() {if (m_num == 0) {return NULL;} else {T * tmp;node * tobedel = top;tmp = top->ptr;top = top->next;if (top == NULL) {base = NULL;}delete tobedel;m_num--;return tmp;}}int getnum(){return m_num;}T * operator[] (int index){node *tmp = top;while (index > 0) index--,(tmp = tmp->next);return tmp->ptr;}bool exist(T *p){node * tmp = top;while (NULL != tmp) {if (tmp->ptr->equals(p))return true;tmp = tmp->next;}return false;}};class mygraph{//struct gnode{element * ptr;gnode * father;//list<gnode> child; this item is no longer needed- -, by my design };gnode root;gnode ** gnodelist; 。
实验二 九宫重排
九宫重排
一、实验目的
A*算法是人工智能领域最重要的启发式搜索算法之一，本实验通过九宫重排问题，强化学生对A*算法的理解与应用，为人工智能后续环节的课程奠定基础。
二、问题描述
给定九宫格的初始状态，要求在有限步的操作内，使其转化为目标状态，且所得到的解是代价最小解(即移动的步数最少)。
如：
三、基本要求
输入：九宫格的初始状态和目标状态
输出：重排的过程，即途径的状态
四、实验组织运行要求
本实验采用集中授课形式，每个同学独立完成上述实验要求。
五、实验条件
每人一台计算机独立完成实验。
六、实验结果
1、初始状态为8 3 4
2 6 5
1 7
七．实验小结
广度优先搜索算法比较可靠，只要问题有解，这种算法总可以得到解，而且得到的是最优解。
但同时也有很大的缺点，例如它的盲目性较大，当目标节点距初始节点较远时将会产生许多无用节点，搜索效率低。
相比之下，使用到代价函数的A*搜索算法，的效率较高。
人工智能九宫格重移——搜索的实验报告
人工智能九宫格重移——搜索1.问题描述：八数码问题也称为九宫问题。
在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层节点进行扩展。
对九宫重排问题，即构造广度优先搜索树，从初始状态，利用广度优先搜索算法逐步找到目标状态的节点。
3.2．状态空间表示状态空间用一维数组表示，每个节点存放在Bfstr结构体中的字符now中，从第一行开始从左往右给九宫格标号0……8，字符串now元素下标代表格子位置，而now数组中对应数组的值代表九宫格中存放的数码，用数值9代表空格。
八数码问题实验报告
八数码问题实验报告八数码问题实验报告引言：八数码问题，也被称为九宫格问题，是一种经典的数学谜题。
在一个3x3的方格中，摆放有1至8的数字，其中一个位置为空。
目标是通过交换数字的位置，将数字按照从小到大的顺序排列，最终使得空格位于最后一个位置。
本实验旨在通过编程实现八数码问题的求解，并探讨不同算法在解决该问题上的效果和优劣。
实验步骤：1. 算法选择在本次实验中，我们选择了广度优先搜索算法和A*算法作为求解八数码问题的两种不同方法。
广度优先搜索算法是一种盲目搜索算法，它通过逐层扩展搜索树，直到找到目标状态。
而A*算法则是一种启发式搜索算法，它结合了广度优先搜索和启发式函数，通过评估每个状态的代价来指导搜索过程，以找到最优解。
2. 算法实现我们使用Python语言实现了以上两种算法。
首先，我们定义了一个表示状态的类，并实现了状态的初始化、移动、判断是否达到目标状态等基本操作。
然后，我们分别编写了广度优先搜索算法和A*算法的求解函数。
在广度优先搜索算法中，我们使用队列数据结构来保存待扩展的状态，以实现逐层扩展的效果；在A*算法中，我们使用优先队列来保存待扩展的状态，并根据启发式函数的值进行优先级排序。
3. 实验结果我们使用了多个测试样例来验证两种算法的求解效果。
实验结果表明，广度优先搜索算法能够找到解，但是在面对状态空间较大的情况下，搜索时间会呈指数级增长。
而A*算法则能够更快地找到最优解，其效率相对较高。
然而，A*算法需要选择合适的启发式函数，并且对于某些特殊情况，可能会陷入局部最优解而无法找到最优解。
4. 结果分析通过对比两种算法的求解结果，我们可以发现广度优先搜索算法和A*算法在时间效率和解的质量上存在一定的差异。
广度优先搜索算法适用于状态空间较小的情况，但是在状态空间较大时效率较低；而A*算法则能够在较短的时间内找到最优解，但需要对问题进行合理的建模和启发式函数的选择。
因此，在实际应用中，我们需要根据问题的规模和特点来选择合适的算法。
人工智能九宫格重移——搜索的实验报告
人工智能九宫格重移——搜索1.问题描述：八数码问题也称为九宫问题。
在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层节点进行扩展。
对九宫重排问题，即构造广度优先搜索树，从初始状态，利用广度优先搜索算法逐步找到目标状态的节点。
3.2．状态空间表示状态空间用一维数组表示，每个节点存放在Bfstr结构体中的字符now中，从第一行开始从左往右给九宫格标号0……8，字符串now元素下标代表格子位置，而now数组中对应数组的值代表九宫格中存放的数码，用数值9代表空格。
重排九宫问题的推广及可解性定理
出了解决该 问题 的高效 算法 。
子， 将 １ ， ２， ３ ， …８随 机 的放 人其 中 的任 意 ８个 格 子
中， 留下 一 个 空 格 ， 位 于 空格 上 、 下、 左、 右 四个 方 向 格 子 中的数 ， 可 以与 空格 交换 位置 ， 如果 通 过有 限次
ｔ ｈ ｅ ｓ ｉ ｍｐ ｌ ｅ ｃ ａ ｓ ｅ ． Ｗｅ ｈ ａ ｖ ｅ ｐ ｒ ｏ ｖ ｅ ｄ ｔ ｈ ｅ ｓ ｕ ｆ ｉ ｆ ｃ ｉ ｅ ｎ ｔ ｃ ｏ ｎ ｄ ｉ ｔ ｉ ｏ ｎ， ａ ｎ ｄ ｅ ｘ ｔ ｅ ｎ ｄ ｔ ｈ ｅ ｐ ｏｂ ｒ ｌ ｅ ｍ，ａ ｎ ｄ ｇ ｅ ｔ ｔ ｈ ｅ ｔ ｈ ｅ ｏ ｒ ｅ ｍ ｏ ｆ
摘
要 ：重排 九 宫 问题 历 史 悠 久 ， 但 到 目前 为止 ， 只 有 关 于 ３×３这种 最 简单情 形 问题 可 行 的
必要条 件 的论 述 。在此证 明 了这 一条 件还 是 充分 条件 ， 并将 该 问题 推 广到 一般 情形 ， 证 明 了问
题 可行 的充要 条件 。在 该 问题 中， 奇数 阶和偶 数 阶情 形有 本质 的差 别 ， 从 所发 现 的解 决奇数 阶
问题 的 方法 出发 ， 发展 了新的 方法 ， 解 决 了偶 数 阶的 问题 。
关键 词 ： 重排 九 宫 ； 可解 ； 逆序 数
中图分 类号 ： Ｔ Ｐ ３ ０ １ ． ６ 文献 标识 码 ： Ａ
Ｇｅ ｎ ｅ ｒ ａ ｌ ｉ ｚ ａ ｔ ｉ ｏ ｎ ｏ ｆ ８ － ｄ ｉ ｇ ｉ ｔ ｐ ｕ ｚ ｚ ｌ ｅ ａ ｎ ｄ ｔ ｈ ｅ ｔ ｈ ｅ ｏ ｒ ｅ ｍ ｏ ｆ ｓ ｏ ｌ ｖ ａ ｂ ｉ ｌ ｉ ｔ ｙ
实验二重排九宫图问题
实验二重排九宫图问题一、问题描述重排九宫图问题在3x3的方格棋盘上放置分别标有数字1、2、3、4、5、6、7、8、9的八张牌，初始状态为S0，目标状态为Sg，可使用算符有：空格上移、空格下移、空格左移、空格右移，它们只允许把空格上、下、左、右的牌移入空格。
要求寻找从初始状态到目标状态的路径。
二、设计思想1、算法选择通过算符移动牌后，可以出现的状态有9！种，数据量较大，因此不宜穷举，考虑到算法的效率，应选择启发式搜索算法。
而对路径的寻找可以看作是搜索满足运算的状态，而这种路径并不是唯一的，如果算法不当还可能陷入死循环，为了能够找出最短的路径，选择A-Star算法较为恰当。
2、算法思想搜索中利用启发式信息，对当前未扩展结点根据设定的估价函数值选取离目标最近的结点进行扩展，从而缩小搜索空间，更快的得到最优解，提高效率。
三、程序设计1、编译运行环境使用C#语言编写，编译器为VS2008，运行环境为Windows+.NetFramework3.52、程序运行流程程序通过文件进行输入、输出，s0.txt中存初始状态，sg.txt中存最终状态，程序运行后如果在100000步内找不到节点则输出找不到路径，如果找到路径则生成path.txt文件，保存从s0到sg的状态路径，3、启发函数启发函数h ( n )为当前结点不在位的数码个数。
由于一次只能移动一个数字位，因此h ( n ) <= h * ( n )，同时有h ( t ) = 0 而且对于结点m和n （n 是m的子结点）有h ( m ) – h ( n ) <= 1 = Cost ( m, n ) 即该启发函数满足单调限制条件，只要扩展到某个结点，就找到了从初始结点到达该结点的最优路径。
4、数据结构1）OPEN表：ArrayList类对象，为可扩展的动态数组，其元素是节点类Node的对象引用。
2）状态节点：Node类对象，数据域包括：状态数据int data；估价：int f；初始节点到当前节点的代价：int h；当前节点到目标节点的代价：int g；3）由于OPEN表的排序耗费的时间较长，而每次处理的都是按代价从小到大进行排序后的第一个节点，因此设计时不对OPEN表进行排序，而是用对象NodefirstNode 在每次扩展后保存OPEN表中最小节点的引用。
西安交大 人工智能 重排九宫格实验报告
int move_down(int num[9]) { int i=0; for (;i<9;i++) if (num[i]==0) break; if (i>5) return 0; else { num[i]=num[i+3]; num[i+3]=0; return 1; } } //空格向左移 int move_left(int num[9]) { int i=0; for (;i<9;i++) if (num[i]==0) break; if (i==0||i==3||i==6) return 0; else { num[i]=num[i-1]; num[i-1]=0; return 1; } } //空格向右移 int move_right(int num[9]) { int i=0; for (;i<9;i++) if (num[i]==0) break; if (i==2||i==5||i==8) return 0; else { num[i]=num[i+1]; num[i+1]=0;
void get_numbers_to(int other_num[9]); int get_nipn(void) {return not_in_position_num;} int get_deapth(void) {return deapth;} int get_evafun(void) {return eva_function;} void set_num(int other_num[9]); void show(void); eight_num& operator=(eight_num&); eight_num& operator=(int other_num[9]); int operator==(eight_num&); int operator==(int other_num[9]); }; //计算启发函数 g(n)的值 void eight_num::cul_para(void) { int i; int temp_nipn=0; for (i=0;i<9;i++) if (num[i]!=target[i]) temp_nipn++; not_in_position_num=temp_nipn; if (this->parent==NULL) deapth=0; else deapth=this->parent->deapth+1; eva_function=not_in_position_num+deapth; } //构造函数 1 eight_num::eight_num(int init_num[9]) { for (int i=0;i<9;i++) num[i]=init_num[i]; } //显示当前节点的状态 void eight_num::show() { cout<<num[0]; cout<<" "; cout<<num[1]; cout<<" "; cout<<num[2];
七年级数学九宫课探究报告怎么写
七年级数学九宫课探究报告怎么写该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。
七年级数学九宫课探究报告怎么写该文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢!本店铺为大家提供各种类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，想了解不同资料格式和写法，敬请关注。
文档下载说明Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document 七年级数学九宫课探究报告怎么写can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to knowdifferent data formats and writing methods, please pay attention!七年级数学九宫课探究报告。
估价函数,重排九宫格
估价函数,重排九宫格
估价函数是在搜索算法中使用的一种评估当前状态的函数，它
用于估计一个状态与目标状态之间的距离或差异。
在重排九宫格这
个问题中，估价函数可以用于评估当前九宫格的状态与目标状态之
间的接近程度。
对于重排九宫格问题，我们可以使用以下几种常见的估价函数：
1. 曼哈顿距离，曼哈顿距离是指当前状态中每个数字到达目标
状态中对应数字位置的曼哈顿距离之和。
曼哈顿距离可以通过计算
每个数字在九宫格中的行数和列数的差值之和得到。
这个估价函数
可以衡量当前状态与目标状态之间的位置差异。
2. 错位数，错位数是指当前状态中与目标状态不匹配的数字个数。
例如，如果当前状态中有两个数字与目标状态不一致，则错位
数为2。
这个估价函数可以衡量当前状态与目标状态之间的数字差异。
3. 启发式函数，启发式函数是一种基于问题特性和经验的估价
函数。
对于重排九宫格问题，可以考虑一些启发式策略，如将每个
数字的移动次数作为估价函数。
具体来说，可以计算每个数字到达目标位置所需的最小移动步数之和作为估价函数。
4. 混合估价函数，混合估价函数是将多个估价函数进行组合得到的估价函数。
可以根据不同的权重来综合考虑曼哈顿距离、错位数和启发式函数等多个因素，以得到更准确的估价结果。
需要注意的是，估价函数只是对当前状态与目标状态之间的差异进行评估，并不能直接指导搜索算法的决策。
在搜索算法中，估价函数通常与其他策略（如A算法）结合使用，以找到最优的解决方案。
以上是针对重排九宫格问题的一些常见估价函数，具体使用哪种估价函数取决于具体情况和问题要求。
重排九宫问题的推广及可解性定理
重排九宫问题的推广及可解性定理重排九宫问题是一个经典的数学问题，有着深远的历史和广泛的应用。
在日常生活中，我们经常会遇到这样的情况：将一个图案重新排列后能得到与原图案相同的图案。
例如，我们可以将一个手机游戏中的关卡重新排列，使得游戏的难度更大。
然而，在某些情况下，我们可能会发现无论如何重排都无法得到与原图案相同的图案。
这就是所谓的重排九宫问题。
本文将介绍重排九宫问题的推广及可解性定理，旨在帮助读者了解这一经典问题的本质及其在实际应用中的意义。
在文章中，我们将通过具体案例和数据来说明重排九宫问题的推广及可解性定理的重要性。
一、重排九宫问题的推广1、什么是重排九宫问题？重排九宫问题是指将一个九宫格图案重新排列后能得到与原图案相同的图案的情况。
例如，下图就是一个重排九宫格图案的例子：2、重排九宫问题的推广虽然重排九宫问题最初是指九宫格图案的重新排列，但是它也可以推广到其他形状的图案。
例如，我们可以将重排九宫问题推广到六宫格图案、十二宫格图案等。
这样一来，重排九宫问题就可以应用到更为广泛的领域。
三、可解性定理1、什么是可解性定理？可解性定理是指对于重排九宫问题，只有在满足一定条件的情况下，才能将图案重新排列成与原图案相同的图案。
这些条件包括：●图案的形状必须为奇形状（如三宫格、五宫格等）。
●图案中心的数字必须为偶数。
2、可解性定理的意义可解性定理对于解决重排九宫问题具有重要意义。
通过认识可解性定理，我们可以在设计图案时考四、应用举例1、手机游戏手机游戏是重排九宫问题的一个常见应用。
在手机游戏中，玩家可以通过重新排列图案来调整游戏的难度。
例如，在某款益智类手机游戏中，玩家需要通过重新排列方块来完成每一关。
2、数学教学重排九宫问题也可以用于数学教学。
通过解决重排九宫问题，学生可以学会如何分析问题、思考问题、解决问题等基本的数学素养。
例如，在小学数学课中，老师可以设计一些重排九宫问题作为练习题，帮助学生提高数学能力。
人工智能实验报告
实验一：知识表示方法一、实验目的状态空间表示法是人工智能领域最基本的知识表示方法之一，也是进一步学习状态空间搜索策略的基础，本实验通过牧师与野人渡河的问题，强化学生对知识表示的了解和应用，为人工智能后续环节的课程奠定基础。
二、问题描述有n个牧师和n个野人准备渡河，但只有一条能容纳c个人的小船，为了防止野人侵犯牧师，要求无论在何处，牧师的人数不得少于野人的人数(除非牧师人数为0)，且假定野人与牧师都会划船，试设计一个算法，确定他们能否渡过河去，若能，则给出小船来回次数最少的最佳方案。
三、基本要求输入：牧师人数(即野人人数)：n；小船一次最多载人量：c。
输出：若问题无解，则显示Failed，否则，显示Successed输出一组最佳方案。
用三元组(X1, X2, X3)表示渡河过程中的状态。
并用箭头连接相邻状态以表示迁移过程：初始状态->中间状态->目标状态。
例：当输入n=2，c=2时，输出：221->110->211->010->021->000其中：X1表示起始岸上的牧师人数；X2表示起始岸上的野人人数；X3表示小船现在位置(1表示起始岸，0表示目的岸)。
要求：写出算法的设计思想和源程序，并以图形用户界面实现人机交互，进行输入和输出结果，如：Please input n: 2 Please input c: 2Successed or Failed?: SuccessedOptimal Procedure: 221->110->211->010->021->000四、实验组织运行要求本实验采用集中授课形式，每个同学独立完成上述实验要求。
五、实验条件每人一台计算机独立完成实验。
六、实验代码Main.cpp#include<iostream>#include"RiverCrossing.h"using namespace std;//主函数void main(){RiverCrossing::ShowInfo();int n, c;cout<<"Please input n: ";cin>>n;cout<<"Please input c: ";cin>>c;RiverCrossing riverCrossing(n, c);riverCrossing.solve();system("pause");}RiverCrossing.h #pragma once#include<list>//船class Boat{public:static int c;int pastor;//牧师int savage;//野人Boat(int pastor, int savage);};//河岸状态class State{public:static int n;int iPastor;//牧师数量int iSavage;//野人数量int iBoatAtSide;//船所在河岸State *pPrevious;//前一个状态State(int pastor, int savage, int boatAtSide);int getTotalCount();//获得此岸总人数bool check();//检查人数是否符合实际bool isSafe();//检查是否安全State operator + (Boat &boat);State operator - (Boat &boat);bool operator == (State &state);};//过河问题class RiverCrossing{private:std::list<State*> openList, closeList;State endState;bool move(State *nowState, Boat *boat);//进行一次决策State* findInList(std::list<State*> &listToCheck, State &state);//检查某状态节点是否在列表中void print(State *endState);//打印结果public:static void ShowInfo();RiverCrossing(int n, int c);bool solve();//求解问题};RiverCrossing.cpp#include"RiverCrossing.h"#include<iostream>#include<stack>#include<algorithm>using namespace std;//类静态变量定义int State::n = 0;int Boat::c = 0;/*=========================Methods for class "Boat"=========================*/ Boat::Boat(int pastor, int savage){this->pastor = pastor;this->savage = savage;}/*=========================Methods for class "State"=========================*/ //构造函数State::State(int pastor, int savage, int boatAtSide){this->iPastor = pastor;this->iSavage = savage;this->iBoatAtSide = boatAtSide;this->pPrevious = NULL;}//获取此岸总人数int State::getTotalCount(){return iPastor + iSavage;}//检查人数是否在0到n之间bool State::check(){return (iPastor >=0 && iPastor <= n && iSavage >= 0 && iSavage <=n);}//按照规则检查牧师得否安全bool State::isSafe(){//此岸的安全：x1 == 0 || x1 >= x2//彼岸的安全：(n-x1) == 0 || (n-x1) >= (n-x2)//将上述条件联立后得到如下条件return (iPastor == 0 || iPastor == n || iPastor == iSavage);}//重载+符号，表示船开到此岸State State::operator+(Boat &boat){State ret(iPastor + boat.pastor, iSavage + boat.savage, iBoatAtSide + 1);ret.pPrevious = this;return ret;}//重载-符号，表示船从此岸开走State State::operator-(Boat &boat){State ret(iPastor - boat.pastor, iSavage - boat.savage, iBoatAtSide - 1);ret.pPrevious = this;return ret;}//重载==符号，比较两个节点是否是相同的状态bool State::operator==(State &state){return (this->iPastor == state.iPastor && this->iSavage == state.iSavage && this->iBoatAtSide == state.iBoatAtSide);}/*=======================Methods for class "RiverCrossing"=======================*/ //显示信息void RiverCrossing::ShowInfo(){cout<<"************************************************"<<endl;cout<<" 牧师与野人过河问题求解 "<<endl;cout<<" by 1040501211 陈嘉生 "<<endl;cout<<"************************************************"<<endl;}//构造函数RiverCrossing::RiverCrossing(int n, int c):endState(0, 0, 0){State::n = n;Boat::c = c;}//解决问题bool RiverCrossing::solve(){openList.push_back(new State(State::n, State::n, 1));while(!openList.empty()) {//获取一个状态为当前状态State *nowState = openList.front();openList.pop_front();closeList.push_back(nowState);//从当前状态开始决策if (nowState->iBoatAtSide == 1) {//船在此岸//过河的人越多越好，且野人优先int count = nowState->getTotalCount();count = (Boat::c >= count ? count : Boat::c);for (int capticy = count; capticy >= 1; --capticy) {for (int i = 0; i <= capticy; ++i) {Boat boat(i, capticy - i);if (move(nowState, &boat))return true;}}} else if (nowState->iBoatAtSide == 0) {//船在彼岸//把船开回来的人要最少，且牧师优先for (int capticy = 1; capticy <= Boat::c; ++capticy) { for (int i = 0; i <= capticy; ++i) {Boat boat(capticy - i, i);if (move(nowState, &boat))return true;}}}}print(NULL);return false;}//实施一步决策，将得到的新状态添加到列表，返回是否达到目标状态bool RiverCrossing::move(State *nowState, Boat *boat){//获得下一个状态State *destState;if (nowState->iBoatAtSide == 1) {destState = new State(*nowState - *boat);//船离开此岸} else if (nowState->iBoatAtSide == 0) {destState = new State(*nowState + *boat);//船开到此岸}if (destState->check()) {//检查人数if (*destState == endState) {//是否达到目标状态closeList.push_back(destState);print(destState);return true;//找到结果} else if (destState->isSafe()) {//检查是否安全if (!findInList(openList, *destState) && !findInList(closeList,*destState)) {//检查是否在表中//添加没出现过的状态节点到open表openList.push_back(destState);return false;}}}delete destState;return false;}//检查给定状态是否存在于列表中State* RiverCrossing::findInList(list<State*> &listToCheck, State &state){for (list<State*>::iterator ite = listToCheck.begin(); ite != listToCheck.end(); ++ite) {if (**ite == state)return *ite;}return NULL;}//根据达到的目标状态，回溯打印出求解过程void RiverCrossing::print(State *endState){cout<<"================================================"<<endl;if (!endState) {cout<<"Search failed!"<<endl;} else {cout<<"Search successed!"<<endl;cout<<"Optimal Procedure: "<<endl;State *pState = endState;stack<State*> st;//用栈将链表逆序，以便输出while (pState) {st.push(pState);pState = pState->pPrevious;}int count = 0;while (!st.empty()) {pState = st.top();st.pop();cout<<pState->iPastor<<","<<pState->iSavage<<","<<pState->iBoatAtSide;if (st.size() > 0)cout<<" -> ";if (++count % 5 == 0)//每五个步骤换行cout<<endl;}cout<<endl;cout<<"Total move: "<<count - 1<<endl;}cout<<"================================================"<<endl;}七、实验结果实验二：九宫重排一、实验目的A*算法是人工智能领域最重要的启发式搜索算法之一，本实验通过九宫重排问题，强化学生对A*算法的理解与应用，为人工智能后续环节的课程奠定基础。
数据结构课程设计之九宫格实验报告
九宫问题一、简介1．设计目的：通过实践掌握用广度优先搜索解决问题的方法2．问题的描述：在一个3*3的九宫中，有1—8这8个数，及一个空格随机的摆放在其中的格子里。
如下面左图所示。
要求实现这样的问题：将九宫问题调整为如右图所示的形式。
调整的规则是：每次只能将与空格（上、下或左、右）相邻的一个数字平移到空格中。
要求：问你通过移动中间的空格是否能达到右图所示的状态，如果能，则输出所走的路径，如果不能，则输出：unsolvable。
最好能画出九宫的图形形式，并在其上动态的演示移动过程。
二、数据结构的设计：1：为了了解九宫格的状态所以需要记录九宫格的当前状态2：因为要采用是两端同时开始搜索的方法，所以要记录结点是从那个方向搜索到的3：为了减少重复搜索，所以要记录当前状态是由父结点怎么移动得来的4：需要输出路径，所以得记录从根节点到当前结点空格的移动路径5：需要一个队列来实现广度优先搜索6：还需要以一种便于访问的方式记录下所有已经访问过的结点，所以构造一个哈希表7：便于找到答案后释放所用空间，还需要将所有已搜索过的结点构造成一个链表综上定义如下结构体：typedef struct LNode{int data;//用一个各位不相等的9位数来表示当前状态，9表示空格int flag;//0表示由初始状态生成，1表示由末状态生成int fangxaing;//表示双亲结点生成此结点时空格的移动方向char *path;//存放路径的数组下标，比实际值小1struct LNode *next,*next1;//next用于队列中，next1用于链表}LNode,*Linklist;typedef struct {Linklist front,rear;}LinkQueue,*Queue;Linklist *hxb;//哈希表hxb=(Linklist*)calloc(362881,sizeof(Linklist));哈希函数为所有比表示这个状态的各位不相等的九位数小的各位不相等的九位数的个数，所以不会产生冲突三、功能（函数）设计：本程序的人物要求是完成九宫格的求解并输出结果，根据任务要求，总体上可以分为五个功能模块，分别为：1：程序功能介绍和操作提示模块：在主函数int main()中显示，用于程序功能的介绍和操作提示。
重排九宫实验报告
重排九宫实验报告重排九宫算法实验报告1实验⽬的运⽤搜索算法重排九宫使之从初始状态到底⽬标状态，并求解最短路径。
2 实验内容⽤三种不同的搜索算法实现重排九宫。
本实验⽤的⽅法分别是：A*算法、有界深度优先搜索和⼴度优先搜索。
3 实验原理启发式搜索是在搜索中加⼊了与问题有关的启发性信息，⽤以指导搜索朝着最有希望的⽅向前进，加速问题的求解过程并找到最优解。
A*算法是⼀种启发式搜索。
⼴度优先搜索按照“先扩展出的节点先被考察”的原则进⾏搜索。
深度优先搜索按照“后扩展出的节点先被考察”的原则进⾏搜索。
有界深度优先搜索的原则与深度优先搜索相同，但是它规定了深度限界，使搜索不得⽆限制地向纵深⽅向发展。
4解存在算法如下图所⽰：判断是否有解的算法如下：public class Method {public static boolean Parity(int a[]){boolean parity=true;for(int i=0;iint k=i;for(int j=i+1;jif(a[k]>a[j]){k=j;}}if(k!=i){int temp;temp=a[i];}}return parity;}public static boolean isSolutionExist(int src[],int dest[],int s[][],int d[][]){ int row1=0,row2=0,clumn1=0,clumn2=0; boolean flag1,flag2;for(int i=0;i<3;i++){for(int j=0;j<3;j++){if(s[i][j]==0){row1=i;clumn1=j;}if(d[i][j]==0){row2=i;clumn2=j;}}}if((row1-row2+clumn1-clumn2)%2==0){flag1=true;}else{flag1=false;}if(Parity(src)==Parity(dest)){flag2=true;}else{flag2=false;}if(flag1==flag2){return true;}else{return false;}节点数据结构private static class Node{int data[][]; //状态int row; //0所在⾏int clumn; //0所在列Node parent; //⽗亲节点Node(int data[][],Node parent,int row,int clumn){ this.data=data;this.parent=parent;this.row=row;this.clumn=clumn;}}运⾏截图1.初始化状态2.初始状态随机3.初始和⽬标状态都为随机6有界深度优先搜索节点数据结构private static class Node{boolean flag=false;int depth=-1;int data[][];int row;int clumn;Node parent;Node(int data[][],Node parent,int row,int clumn,int depth){ this.data=data; this.parent=parent;this.row=row;this.clumn=clumn;this.depth=depth;}运⾏截图1.7 A*算法节点数据结构private static class Node{int value; //估价函数的值int diff=0; //当前节点到⽬标节点的最⼩代价int depth=-1; //初始节点到当前节点的代价int data[][];int row;int clumn;Node parent;Node(int data[][],Node parent,int row,int clumn,int depth,int diff){ this.data=data; this.parent=parent;this.row=row;this.clumn=clumn;this.depth=depth;this.diff=diff;this.value=depth+diff;}}7 A*算法运⾏截图。
重排九宫格
重排九宫格问题一．问题描述在3*3的方格棋盘上放置分别标有数字1,2,3,4,5,6,7,8的8张牌，初始状态为s0，目标状态为sg，可使用的算符有空格左移，空格上移，空格右移和空格下移，即它们只允许把位于空格左，上，右，下边的牌移入空格。
要求寻找从初始状态到目的状态的路径。
二．算法描述（1）把初始节点S0放入OPEN表。
（2）如果OPEN表为空，则问题无解，退出。
（3）把OPEN表的第一个节点取出放入CLOSE表（记为节点n）。
（4）考察节点n是否为目标节点。
若是，则求得了问题的解，退出。
（5）若节点n不可扩展，则转第2步。
（6）扩展节点n，将其子节点放入OPEN表的尾部，并为每一个子节点都配置指向父节点的指针，然后转第2步。
三.实验结果四.实验结果分析应用广度优先搜索可得到如上图所示的从初始状态到目标状态的路径。
广度优先搜索盲目性较大，当目标节点距初始节点较远时将会产生许多无用节点，搜索效率低。
但只要问题有解，用广度优五．源代码#include <iostream>using namespace std;#include "classes.h"char element::ebegin[3][3] = {{2,8,3},{1,0,4},{7,6,5}};char element::dest[3][3] = {{1,2,3},{8,0,4},{7,6,5}};double element::k = 1; // if you change the k val, you may get different result.int main() {list<element> open, close; // these are two list that holds the tree node.element ebegin(element::ebegin);mygraph G(&ebegin);// step 1open.pushtop(&ebegin);//G.add(&ebegin);--> the construction function did it very well.while(1){// step 2if (open.getnum() == 0) {cout<<"This question has no solution."<<endl;break;}/*if (close.getnum()>362880){cout<< "out of bound error"<<endl;break;}*/// step 3element * n;close.pushend(n = open.pop());// step 4if (element::reach(n)){cout<<"solution got:";G.drawtree(n);cout<<"Total steps:"<<n->layer<<endl;break;}//step 5element * M[4];// extend the nodeM[0] = n->goup();M[1] = n->godown();M[2] = n->goleft();M[3] = n->goright();int i;for (i = 0; i < 4 ; i++) {if (M[i] == NULL) continue;if (!G.exist(M[i])){// aG.add(M[i],n);//M[i]->draw();if (!open.exist(M[i]) && !close.exist(M[i]))open.pushbyforder(M[i]);}else{// b & cG.changeparent(M[i], n);}}// 7 order has beeen down in inserting.// 8 when we reached here, we will go to the front.}system("pause");return 0;}classes.hstruct point {int x;point (int px, int py){x = px; y = py;}};class element {public:char m[3][3];static char dest[3][3];static char ebegin[3][3];int layer;static double k;int f_val;element(char s[3][3], int l = 0) {layer = l + 1;for (int i = 0; i < 3 ; i++) {for(int j = 0; j < 3; j++) {m[i][j] = s[i][j];}}this->f();}point getpos(){for (int i = 0; i < 3 ; i++) {for(int j = 0; j < 3; j++) {if (m[i][j] == 0)return point(i, j);}}system("echo unable &pause");}int f(){int g = 0;for(int i = 0; i < 3; i++) {for (int j = 0; j < 3; j++) {if (m[i][j] == dest[i][j]) {g += 0;} else {g += 1;}}}f_val = (int)(layer + k * g);return f_val;}point p = this->getpos();if (p.x > 0){element* pnew = new element(m, layer);pnew->m[p.x][p.y] = pnew->m[p.x - 1][p.y];pnew->m[p.x - 1][p.y] = 0;return pnew;}return NULL;}element * godown(){point p = this->getpos();if (p.x < 2){element* pnew = new element(m, layer);pnew->m[p.x][p.y] = pnew->m[p.x + 1][p.y];pnew->m[p.x + 1][p.y] = 0;return pnew;}return NULL;}element * goleft(){point p = this->getpos();if (p.y > 0){element* pnew = new element(m, layer);pnew->m[p.x][p.y] = pnew->m[p.x][p.y - 1];pnew->m[p.x][p.y - 1] = 0;return pnew;}return NULL;}element * goright(){point p = this->getpos();if (p.y < 2){element* pnew = new element(m, layer);pnew->m[p.x][p.y] = pnew->m[p.x][p.y + 1];pnew->m[p.x][p.y + 1] = 0;return pnew;}return NULL;}static bool reach(element * p){for(int i = 0; i < 3; i++) {for(int j = 0; j < 3; j++) {if (p->m[i][j] != dest[i][j])return false;}return true;}void draw(){cout<<endl;for (int i = 0; i < 3 ; i++) {cout<<'|';for(int j = 0; j < 3; j++) {cout<<(int)m[i][j]<<' ';}cout<<'|'<<endl;}}bool equals(const element *p){for(int i = 0; i < 3; i++) {for(int j = 0; j < 3; j++) {if (p->m[i][j] != this->m[i][j])return false;}}return true;}};template <class T>class list{struct node {T * ptr;node * next;};node * base; // stack base pointernode * top; // stack top pointerint m_num;public:list(){m_num = 0; base = top = NULL;}bool pushtop(T * tp) {if (base == NULL) {base = top = (node *)malloc(sizeof(node));base->next = NULL;} else {node * tmp;tmp = (node *)malloc(sizeof(node));tmp->next = top;m_num++;return true;}bool pushbyforder(T* tp){if (base == NULL) {base = top = (node *)malloc(sizeof(node));base->next = NULL;top->ptr = tp;} else {node * tmp, *find = top;tmp = (node *)malloc(sizeof(node));tmp->ptr = tp;while (find != NULL) {if (tmp->ptr->f_val < find->ptr->f_val) {tmp->next = find->next;find->next = tmp;if (find == top) {top = tmp;}break;}find = find->next;}if (find == NULL){base->next = tmp;tmp->next = NULL;base = tmp;}}m_num++;return true;}bool pushend(T * p) {if (base == NULL) {base = top = (node *)malloc(sizeof(node));base->next = NULL;} else {node * tmp;tmp = (node *)malloc(sizeof(node));base->next = tmp;tmp->next = NULL;m_num++;return true;}T * pop() {if (m_num == 0) {return NULL;} else {T * tmp;node * tobedel = top;tmp = top->ptr;top = top->next;if (top == NULL) {base = NULL;}delete tobedel;m_num--;return tmp;}}int getnum(){return m_num;}T * operator[] (int index){node *tmp = top;while (index > 0) index--,(tmp = tmp->next);return tmp->ptr;}bool exist(T *p){node * tmp = top;while (NULL != tmp) {if (tmp->ptr->equals(p))return true;tmp = tmp->next;}return false;}};class mygraph{//struct gnode{element * ptr;//list<gnode> child; this item is no longer needed- -, by my design };gnode root;gnode ** gnodelist; 。
4.1.2重排九宫问题的状态树表示
Q
注意：同一种棋盘状态不能重复出现
【状态树生成过程】
【状态树的表示方法】
（1）这棵树共有几层？根节点是哪个？ （2）什么是分支？节点B2有几个分支？ （3）请举例说明分支节点、父节点、子节点和叶节点。
【迷宫问题】
下图是一个迷宫，S0是入口，Sg是出口，把 入口作为初始节点，出口作为目标节点，通 道作为分支，画出从入口S0出发，寻找出口 Sg的迷宫问题的状态树。
下图是一个迷宫s0是入口sg是出口把入口作为初始节点出口作为目标节点通道作为分支画出从入口s0出发寻找出口sg的迷宫问题的状态树
4.1 重排九宫问题及其树表示
【重排九宫问题】 有一个3*3的方格棋盘，上面有8个棋子和一个 空格，移动与空格相邻的棋子可以生成新的棋 盘状态。 Q1：若每步只移动一个棋子，共有几种移法？
Q 为什么要画状态树？
如果我们想让计算机帮助我们解 决生活中遇到的问题，就必须把待解 决的问题表示成某种固定的形式。
【四皇后问题】
一个4*4国际象棋盘，依次放入四个皇后。每行、 每列及对角线上只允许出现一枚棋子。每次只能 将一个棋子放在当前行的下一行。请依据下列规 则画出状态树，找到所有合法布局。 规则： i表示棋子所在行，j表示棋子所在列（1≤i,j≤4） 如（12）有哪些收获？
粤教版高中信息技术选修5人工智能初步：重排九宫问题及其树的表示
棋子的四种移动方法
（2）为了减少移动的次数，在移动过程中，约定同一种棋盘 状态，不能重复出现。例如下图中，棋盘状态③和⑤相同，则从状 态④不能选择d移动方法，但从状态③可以选择b移动方法，生成与 已有状态不重复的新状态。
一种不合规定的棋子移动过程
2
重排九宫问题的状 态树表示
在后图中，画出了只移动4步的情况下，所生成的重排九宫问 题的五层状态树。
重排九宫问题及其 树的表示
数码的8个棋子（1，2，3，4，5，6， 7，8），并留有一个空格，如图所示。 通过移动棋子，可以生成不同的棋盘 状态。棋子移动规则如下：
（1）与空格垂直、水平方向的 数码棋子均可以移至空格处，每步只 能移动一个棋子，棋子共有四种移法， 如图所示的a、b、c、d。
（5）父节点、子节点：能生成新节点的节点称为父节点，被 生成的节点称为子节点，如SO是B1的父节点，B1是SO的子节点， B1又是C1、C2的父节点，C1、C2是B1的子节点，其他依次类推。 根节点SO没有父节点。 （6）叶节点：在树上，没有分支的节点是树的叶节点，如E1， E2等。与自然界的树不同的是，用于表示重排九宫问题的棋盘 状态树是倒立的，根在最上面；相同的是整棵树只有一个根， 有多个分支和多个叶节点。
（1）图中S0表示棋盘的初始状态，我们称为树的根节点。 （2）每移动一个棋子，称为一次操作，通过前面的实践，我 们知道，对于任意棋盘状态来说，最多只有四种操作a、b、c、d。 在树种用节点间的连线表示操作，如SO与B1之间的连线表示操作a （空格左方的棋子右移）。
重排九宫问题状态树
（3）每进行一种操作，就会生成一个新的棋盘状态。若 把生成的新状态按先后次序连接起来，如上图中：S0—B1、 B1—C1、B1—C2、S0—B2、SO—B3、SO—B4，依次类推，可以 构成重排九宫问题的状态树。
人工智能论文：九宫重排问题
滨江学院课程论文课程名称:人工智能院系滨江学院专业自动化学号姓名指导老师二Ｏ一六年六月二十日引言 (3)一、问题描述 (3)1.1 待解决问题的解释 (3)1.2 问题的搜索形式描述（4要素） (3)1.3 解决原理 (4)二、算法介绍 (4)2.1 搜索算法一般介绍 (4)2.2 算法伪代码 (5)三、数据介绍 (7)3.1 数据结构 (7)3.2 实验结果 (8)3.3 系统中间及最终输出结果（要求有屏幕显示） (9)参考文献 (11)人工智能是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。
人工智能的研究方向、研究领域、应用领域值得我们关注和探讨。
本文以状态空间搜索的观点讨论了八数码问题，给出了八数码问题的Java 算法与实现的思想，分析了A*算法的可采纳性等及系统的特点。
关键词:九宫重排，状态空间，启发式搜索，A*算法引言九宫重排问题是人工智能当中有名的难题之一。
问题是在3×3方格盘上，放有八个数码，剩下一个位置为空，每一空格其上下左右的数码可移至空格。
问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始状态转化为目标状态。
状态转换的规则：空格四周的数移向空格，我们可以看作是空格移动，它最多可以有４个方向的移动，即上、下、左、右。
九宫重排问题的求解方法，就是从给定的初始状态出发，不断地空格上下左右的数码移至空格，将一个状态转化成其它状态，直到产生目标状态。
一、问题描述1.1 待解决问题的解释八数码游戏（八数码问题）描述为：在3×3组成的九宫格棋盘上，摆有八个将牌，每一个将牌都刻有1-8八个数码中的某一个数码。
棋盘中留有一个空格，允许其周围的某一个将牌向空格移动，这样通过移动将牌就可以不断改变将牌的布局。
这种游戏求解的问题是：给定一种初始的将牌布局或结构（称初始状态）和一个目标的布局（称目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。
中班科学九宫格反思
中班科学九宫格反思活动目标1、在玩一玩摆一摆中体会九宫格游戏的乐趣。
2、认识九宫格，观察发现图案排列规律，学会按照规律排列。
3、根据数独规律，摆放 44 宫格内的数字。
4、发展合作探究与用符号记录实验结果的能力。
5、发展幼儿的观察力、想象力。
重点难点教学重点：学会按照规律排列。
教学难点：摆放44宫格内的数字。
活动准备经验准备：有过找规律的经验、对横排和竖排有清晰的认识。
材料准备：九宫格图谱、底板、小动物图片、数字、作业单、铅笔、PPT。
环境准备：地面九宫格。
活动过程1、游戏导入：师：今天我们这里来了很多客人老师，我们和客人老师一起玩一个好玩的游戏好吗（教师介绍游戏规则及动作。
）2、发现九宫格规律：(1)刚才我们玩的九宫格游戏吸引了很多的小动物，它们也想参加, 你们看看他们是谁口(2)找规律。
□看看来了几个小动物口你发现他们排列的规律了吗它们有没有重复口小结：33宫格里每一横排、每一竖排都有三个不同的小动物，而且这三个小动物的排列不重复。
□(3)分组游戏：小动物拼拼拼口3、探索发现口(1)介绍新来的小动物。
□(2)小动物躲猫猫。
□动物们都躲在了小问号后面，你想先从哪个小问号开始猜呢为什么是谁躲在这里口4、示PPT4，讲解数独口根据九宫格图片摆放规律，发现“数独”规律。
根据数独规律，探索发现44宫格口里的数字摆放规律。
□(1)师：我这里有很多游戏单如果完成数字游戏单，就可以玩更有意思的游戏了。
□教师宣布填写规则：横排竖排都不能重复。
D幼儿分组完成数字游戏单。
□（2）纠错总结口师：我发现有小朋友是这样排列的，大家一起来看看，有没有不同意见为什么应该是怎样的（和孩子一起总结每一行，每一列不重复）师：孩子们，你们刚才在做游戏单时，先从哪里开始的为什么（排除法）总结：你们已经找到了很好的方法，知道从数字最多的一横排或者一竖排开始找，这样就容易找到答案了。
□五、延伸活动：口邀请客人老师上来一起来玩九宫格游戏。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
重排九宫算法实验报告
1实验目的
运用搜索算法重排九宫使之从初始状态到底目标状态，并求解最短路径。
2 实验内容
用三种不同的搜索算法实现重排九宫。
本实验用的方法分别是：A*算法、有界深度优先搜索和广度优先搜索。
3 实验原理
启发式搜索是在搜索中加入了与问题有关的启发性信息，用以指导搜索朝着最有希望的方向前进，加速问题的求解过程并找到最优解。
A*算法是一种启发式搜索。
广度优先搜索按照“先扩展出的节点先被考察”的原则进行搜索。
深度优先搜索按照“后扩展出的节点先被考察”的原则进行搜索。
有界深度优先搜索的原则与深度优先搜索相同，但是它规定了深度限界，使搜索不得无限制地向纵深方向发展。
4解存在算法
如下图所示：
判断是否有解的算法如下：
public class Method {
public static boolean Parity(int a[]){
boolean parity=true;
for(int i=0;i<a.length;i++){
int k=i;
for(int j=i+1;j<a.length;j++){
if(a[k]>a[j]){
k=j;
}
}
if(k!=i){
int temp;
temp=a[i];
a[i]=a[k];
a[k]=temp;
parity=!parity;
}
}
return parity;
}
public static boolean isSolutionExist(int src[],int dest[],int s[][],int d[][]){ int row1=0,row2=0,clumn1=0,clumn2=0;
boolean flag1,flag2;
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(s[i][j]==0){
row1=i;
clumn1=j;
}
if(d[i][j]==0){
row2=i;
clumn2=j;
}
}
}
if((row1-row2+clumn1-clumn2)%2==0){
flag1=true;
}else{
flag1=false;
}
if(Parity(src)==Parity(dest)){
flag2=true;
}else{
flag2=false;
}
if(flag1==flag2){
return true;
}else{
return false;
}
}
5广度优先搜索
节点数据结构
private static class Node{
int data[][]; //状态
int row; //0所在行
int clumn; //0所在列
Node parent; //父亲节点
Node(int data[][],Node parent,int row,int clumn){ this.data=data;
this.parent=parent;
this.row=row;
this.clumn=clumn;
}
}
运行截图
1.初始化状态
2.初始状态随机
3.初始和目标状态都为随机
6有界深度优先搜索
节点数据结构
private static class Node{
boolean flag=false;
int depth=-1;
int data[][];
int row;
int clumn;
Node parent;
Node(int data[][],Node parent,int row,int clumn,int depth){ this.data=data;
this.parent=parent;
this.row=row;
this.clumn=clumn;
this.depth=depth;
}
}
运行截图
1.7 A*算法
节点数据结构
private static class Node{
int value; //估价函数的值
int diff=0; //当前节点到目标节点的最小代价
int depth=-1; //初始节点到当前节点的代价
int data[][];
int row;
int clumn;
Node parent;
Node(int data[][],Node parent,int row,int clumn,int depth,int diff){ this.data=data;
this.parent=parent;
this.row=row;
this.clumn=clumn;
this.depth=depth;
this.diff=diff;
this.value=depth+diff;
}
}
7 A*算法
运行截图。