【问题描述】
题目6：数阵问题
每个局面是三行三列的数字方阵，每个位置为0-8的一个数码且互不相同，求从初始局面（自己设定）如何“最快”移动到终止局面（自己设定）。
移动规则：每次只能0与其上下左右四个方向相邻的某个数字交换！可能有解，可能无解。
| 0 |
1 |
2 |
|
? |
|
1 |
2 |
3 |
| 3 |
4 |
5 |
|
=》 |
|
4 |
5 |
6 |
| 6 |
7 |
8 |
|
|
|
7 |
8 |
0 |
【需求分析】
一、基本功能
1.用户自己设定初始界面、终止界面，九宫格上方块可移动；
2.根据初始界面和终止界面，打印出移动的路径。
二、附加功能
1.用户移动九宫格的回退功能；
2. 使用了A*搜索、全局择先、宽度优先三种算法，对移动路径进行搜索；
3. 针对A*搜索和全局择先算法，设计了四种估值函数；
4. 判断在指定估值函数、指定算法的情况下，移动的步数及时间，将结果存储至数据库，并在前端回显。
【概要设计】
一、系统信息
开发的硬件环境
CPU：11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz 2.30 GHz
RAM：16.0 GB
开发该系统的操作系统
版本：Windows 10 家庭中文版
软件开发环境/开发工具
Intellij IDEA2021.1.1
Visual Studio Code
HBuilder X
Postman、ApiPost7
编程语言
Java
技术点
后端技术：Springboot、SpringMVC、knife4j、Mybatis-plus、MySQL、maven、lombok
前端技术：HTML、CSS、JavaScript、Vue、JQuery、Element-ui、Layui、axios
二、功能模块
根据需求，设计的八数码求解系统的功能有，九宫格的移动、搜索移动路径、状态记录这三大类。详情如图 1所示：
图 1 系统功能图
三、项目架构
（一）MVC三层架构
表 1 MVC架构表
| 层次 |
作用 |
设计原则 |
| 模型层（MODEL） |
封装应用的一系列数据，并定义操作，处理这些数据的逻辑和计算规则 |
通过调用接口对控制器进行反馈 |
| 视图层 （VIEW） |
视图对象的主要目的之一是将应用模型对象中的数据显示出来，并允许用户编辑该数据 |
通过ajax发送异步请求，和控制器进行反馈 |
| 控制器层（CONTROLLER） |
控制器是在视图层和若干个模型层的中间人 |
直接操作模型层和视图层 |
（二）包结构
项目使用的是基本的MVC三层架构，其中common包下存放通用实体类，config下是对tomcat服务器的配置信息，controller包下是控制层，mapper层下是数据库操作的Interface接口，service是业务层，system下是实体类，vo包下定义的类是值对象，用来传递数据和信息。包目录结构如图 2所示。
图 2 项目包目录
四、存储结构
在JavaEE开发设计的过程中，和C语言的结构体类似，Java中的存储放在一个实体类中。比如跟三种算法相关的信息，我存放在了Node节点和Algorithm节点中，节点Node的存储结构如图 9所示
表 2 节点Node的存储结构
| 数据项名称 |
数据项系统表示 |
数据类型 |
数据长度 |
备注 |
| 存放顶点数据 |
num |
int[][] |
3*3 |
|
| 移动步数/深度 |
depth |
int |
|
|
| 逆序数 |
Reverse_order_number |
int |
|
|
| 父节点移动方向 |
direction |
int |
|
|
| 估值函数值 |
worth |
int |
|
|
Node类的代码如下：
public class Node {
public int[][] num =new int [3][3]; //用于存放节点数据
public int depth; //移动步数/深度
int Reverse_order_number; //逆序数
public int direction;//1 2 3 4 分别为上下左右
public int worth; //启发式函数的值
}节点Algorithm的存储结构如表 3所示：
表 3 Algorithm的存储结构
| 数据项名称 |
数据项系统表示 |
数据类型 |
数据长度 |
备注 |
| num的初始状态 |
num_Initial |
int[][] |
3*3 |
|
| num的结束状态 |
num_Eventual |
int[][] |
3*3 |
|
| 开始时间 |
starTime |
long |
|
|
| 最大搜索长度 |
MAX_SEARCH_DEPTH |
int |
|
|
类Algorithm的源码如下所示：
public class Algorithm {
public static int[][] num_Initial =new int [3][3];
public static int[][] num_Eventual =new int [3][3];
public static long starTime;
public static int MAX_SEARCH_DEPTH=100;
}函数执行结果的存储类为StepAndTime，存储结构如下：
表 4 StepAndTime存储结构
| 数据项名称 |
数据项系统表示 |
数据类型 |
数据长度 |
备注 |
| 主键 |
id |
String |
|
|
| 算法名 |
algorithm_name |
String |
|
|
| 估值函数 |
algorithm_value_estimate |
String |
|
|
| 时间花费 |
time_cost |
String |
|
|
| 步数 |
step |
int |
|
|
StepAndTime类的代码如下：
public class StepAndTime {
private String id;
private String algorithm_name;
private String algorithm_value_estimate;
private String time_cost;
private int step;
}这里的StepAndTime节点存放至了数据库，可实现数据库的增删改查的功能，其中表step_and_time的结构如图 3所示。
图 3 数据库存储
【详细设计】
一、九宫格的移动
（一）移动九宫格
在前端界面中放置了两个九宫格，每个九宫格里都是1-8的八个数，第一个九宫格代表初始状态，第二个九宫格代表的是目标状态，用户点击空块，即九宫格除8个有数字的块以外的块时，该块会和空块做交换，交换逻辑如图 4所示。
图 4 点击方块的移动效果
（二）记录九宫格状态、移动状态
用一个ti2数组对九宫格状态进行记录，用字符串拼接的方式对九宫格移动的状态进行记录(用于回退)，将内容打印在控制台中。
图 5 记录九宫格状态
（三）回退功能
点击下面的回退按钮，会返回前一个九宫格状态。
二、搜索路径
（一）全局择优算法
全局择优搜索属于启发式搜索，即利用已知问题中的启发式信息指导问题求解，而非蛮力穷举的盲目搜索。
启发式信息：即，可用于指导搜索过程，且与具体问题求解有关的控制性信息。
启发函数：用于描述启发式信息的数学模型，称为启发函数，根据问题特点和看待问题的角度不同，同一问题，可以定义多个启发函数。
全局择优算法的执行流程是先把初始节点S0放入OPEN表中，根据当前结点的深度和当前结点和目标结点差异的度量，计算出启发函数f(S0),如果OPEN表为空，那么问题没有解，直接退出程序，如果OPEN表还不为空，那就把OPNE表的第一个节点n放入CLOSED表，考察该节点是否是目标结点，如果是的，那就可以直接得出问题解，从而退出程序，如果还没找到目标节点，则节点n不可以扩展，转到Step2,如果节点n可以扩展，则扩展该节点，用估值函数f(n)计算每个节点的估价值，并给每个子结点配置指向父结点的指针，把这些子节点都放入OPEN表中，然后对OPEN表中的所有节点按照估值函数f(n)的大小进行排序，再转到Step2去，全局择优算法的执行流程如表 5所示。
表 5 全局择优算法执行流程
| 步骤 |
全局择优算法流程 |
| Step1 |
把初始节点SO放入OPEN表，f(S0) |
| Step2 |
如果OPEN表为空，则问题无解，退出 |
| Step3 |
把OPEN表的第一个节点(记为节点n)取出放入CLOSED表 |
| Step4 |
考察节点n是否为目标节点。若是，则求得问题的解，退出 |
| Step5 |
若节点n不可扩展，则转Step2 |
| Step6 |
扩展节点n，用启发函数f(x)计算每个子节点的估价值，并为每个子节点配置指向父节点的指针，把这些子节点都送入OPEN表中，然后对OPEN表中的全部节点按估价值从小到大的顺序进行排序，然后转Step2 |
（二）A*搜索算法
A*搜索算法相对于全局择优算法改动非常小，只增加了个别函数，全局择优、A算法和A*算法的定义、区别介绍如表 6所示：
表 6 A算法、A*算法定义
| 定义 |
全局择优算法流程 |
| 定义1 |
在GRAPHSEARCH过程中，如果重排OPEN表是依据f(x)=g(x)+h(x)进行的，则称该过程为A算法 |
| 定义2 |
在A算法中，如果对所有的x，h(x)<=h*(x）成立,则称h(x)为h*(x)的下界，它表示某种偏于保守的估计 |
| 定义3 |
采用h(x)的下界h*(x)为启发函数的A算法称为A*算法 |
A*算法是在A算法的基础上，每生成一个新节点，即查找closed表，如果closed表中有相同排列的结点，那么则比较他们的权重(f(n))，如果新节点的权重更小，则替代原结点，即，刷新原结点的深度，这样就很有可能找到更短、更快的到达目标结点的路径。A*算法执行的流程图如图 6所示
图 6 A*算法执行流程图
（三）宽度优先算法
宽度优先算法是一种盲目搜索算法，即，蛮力法；需要一个Open表，把起始节点放入Open表中，如果Open表为空，则无解并退出，否则，继续把第一个节点n从Open表中移除，并放入CLOSED扩展节点表中。这里要考察节点n是不是目标节点，如果是的话，就代表求出答案了，则可以退出，如果节点n往下不可以接着扩展了，那么转到第二步，继续从OPEN表中选节点，放入CLOSED表考察。如果节点n可扩展，则把所有n的子节点放入OPEN表的尾部，配置父节点指针，继续转Step2开始下一轮判断。算法流程如表 7所示。
表 7 宽度优先算法流程表
| 步骤 |
宽度优先算法流程 |
| Step1 |
把起始节点放到OPEN表中 |
| Step2 |
如果OPEN是个空表，则没有解失败退出;否则继续 |
| Step3 |
把第一个节点 (节点n) 从OPEN表移出，并把它放入CLOSED扩展节点表中 |
| Step4 |
考察节点n是否为目标节点。如果是，则求得了问题的解，退出 |
| Step5 |
如果节点n不可扩展，则转Step2 |
| Step6 |
把n的所有子节点放到OPEN表的尾部，并为其配置指向父节点的指针然后转第Step2步 |
算法流程图如图 7所示
图 7 宽度优先算法流程图
（四）四种估值函数
对于全局择优和A*搜索这两种算法，为了求取最优解，可以设置不同的估值函数，测试看不同的效果。这里选择了四种估值函数，估值函数的解释如图 8所示。
图 8 四种估值函数
这里的Evaluate1和Evaluate2的启发函数定义为当前结点与目标结点差异的度量，这里的“差异”，可以是当前节点与目标节点相比，位置不符的数字个数，也可以是当前节点和目标节点格局相比，位置不符的数字移动到目标节点中对应位置的最短距离之和。
Evaluate3定义为每一对逆序数字乘以一个倍数，即该状态下 逆序数个数与目标状态逆序数个数的绝对值乘以权重。
Evaluate4是为了克服仅在计算数字逆序数字量策略的局限，启发函数定义为位置不符数字个数的总和+3倍逆序数字序列。
三、状态记录
前端使用了el-table表格，对八数码路径查找执行时的用时、步数等进行了数据的持久化存储，并利用axios调用后端接口，实现了数据的回显。在前端显示的表格中，部分数据如图 9所示。
图 9 数据记录表的部分数据
【编码实现】
由于主要功能的实现是通过估值函数类&&算法类实现的，所以在这里，仅对四种估值函数和三种算法做介绍。
一、估值函数
（一）估值函数1
启发函数 h(n)定义为当前节点与目标节点差异的度量：即当前节点与目标节点格局相比，位置不符的数字个数。其中，估值函数Evaluate1的代码如下：
public int Evaluate1(int a[][],int[][] num_Finish) {
int n = 0;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (a[i][j] != num_Finish[i][j])
++n;//找两个状态有多少个格子位置错了
}
}
return n;
}（二）估值函数2
启发函数 h(n)定义为当前节点与目标节点距离的度量：当前节点与目标节点格局相比，位置不符的数字移动到目标节点中对应位置的最短距离之和。其中估值函数Evaluate2如下：
public int Evaluate2(int a[][],int[][] num_Finish) {
int h = 0;// 代价
//找到这个数在初始状态和目标状态的位置在哪
for (int i = 0; i < 9; ++i) {
int m, n;
for (m = 0; m < 9; ++m)
//二维数组遍历找0-8中的数字i，找到就往下
if (a[m / 3][m % 3] == i) break;
for (n = 0; n < 9; ++n)
if (num_Finish[n / 3][n % 3] == i)//找到就往下
break;
//行序差+列序差
h += Math.abs((m / 3) - (n / 3)) + Math.abs((m % 3) - (n % 3));
}
return h;
}
（三）估值函数3
启发函数 h(n)定义为每一对逆序数字乘以一个倍数，即h(n)=|该状态逆序数个数-目标状态逆序数个数| * 权重
public int Evaluate3(int a[][],int[][] num_Finish) {
int weight=Math.abs(ReverseNumber(a)-ReverseNumber(num_Finish));
return weight*Math.abs(ReverseNumber(a)-ReverseNumber(num_Finish));
}
（四）估值函数4
为克服了仅计算数字逆序数字数目策略的局限 启发函数 h(n)定义为位置不符数字个数的总和+ 3 倍数字逆序数目。
public int Evaluate4(int a[][],int[][] num_Finish) {
return Evaluate1(a,num_Finish) + 3 * Math.abs(ReverseNumber(a) - ReverseNumber(num_Finish));
}
二、搜索算法
（一）全局择先算法
全局择优算法的执行流程是先把初始节点S0放入OPEN表中，根据当前结点的深度和当前结点和目标结点差异的度量，计算出启发函数f(S0),如果OPEN表为空，那么问题没有解，直接退出程序，如果OPEN表还不为空，那就把OPNE表的第一个节点n放入CLOSED表，考察该节点是否是目标结点，如果是的，那就可以直接得出问题解，从而退出程序，如果还没找到目标节点，则节点n不可以扩展，转到Step2,如果节点n可以扩展，则扩展该节点，用估值函数f(n)计算每个节点的估价值，并给每个子结点配置指向父结点的指针，把这些子节点都放入OPEN表中，然后对OPEN表中的所有节点按照估值函数f(n)的大小进行排序，再转到Step2去，全局择优算法的执行流程如表 5所示。其中，全局择先函数如下：
public int[][][] GlobalSearch2(long info[],int nEvaluate,int[][] num_Begin,int[][] num_Finish) {
starTime = System.nanoTime();
Vector<Node> OPEN=new Vector<Node>();
Vector<Node> CLOSED=new Vector<Node>();
// 添加根节点
OPEN.add(new Node(num_Begin, 0, evaluateService.ReverseNumber(num_Begin), 0, null, evaluateService.Evaluate(num_Begin, 0, nEvaluate,num_Finish)));
while(!OPEN.isEmpty()) {
// 计算可达性,限制搜索深度
if (!isAvailable(OPEN.get(0).num,num_Finish) || OPEN.get(0).depth > MAX_SEARCH_DEPTH) {
return null;
}
CLOSED.add(OPEN.get(0));
OPEN.remove(0);
if(isEqual(CLOSED.lastElement().num,num_Finish)) {
return Route2(CLOSED.lastElement(),info);
}
else {
Node father=CLOSED.lastElement();
int i = 0, j = 0;
// 找到空格
for (int k = 0; k < 9; ++k) {
if (father.num[k / 3][k % 3] == 0) {
i = k / 3;
j = k % 3;
break;
}
}
int dir=father.direction,dep=father.depth;
int a[][]=new int[3][3];
//1 上
if (i != 0&& dir!=2) {
for (int m = 0; m < 3; ++m) {
for (int n = 0; n < 3; ++n) {
a[m][n]=father.num[m][n];
}
}
a[i][j]=a[i-1][j];
a[i-1][j]=0;
OPEN.add(new Node(a, dep + 1, evaluateService.ReverseNumber(a), 1, father,evaluateService.Evaluate(a, dep + 1, nEvaluate,num_Finish)));
}
//参照“1 上”，执行下、左、右三个方向的扩展
}
return null;
}
（二）A*搜索算法
A*搜索算法相对于全局择优算法改动非常小，只增加了个别函数，因此在此处省略。
（三）宽度优先算法
宽度优先算法是一种盲目搜索算法，即，蛮力法；需要一个Open表，把起始节点放入Open表中，如果Open表为空，则无解并退出，否则，继续把第一个节点n从Open表中移除，并放入CLOSED扩展节点表中。这里要考察节点n是不是目标节点，如果是的话，就代表求出答案了，则可以退出，如果节点n往下不可以接着扩展了，那么转到第二步，继续从OPEN表中选节点，放入CLOSED表考察。如果节点n可扩展，则把所有n的子节点放入OPEN表的尾部，配置父节点指针，继续转Step2开始下一轮判断。算法流程如表 7所示。WideSearch2函数如下所示：
public int[][][] WideSearch2(long info[],int[][] num_Begin,int[][] num_Finish) {
int[][][] result = {};
starTime = System.nanoTime();
Vector<Node> OPEN = new Vector<Node>();//声明不定长数组
Vector<Node> CLOSED = new Vector<Node>();
// 把初始节点送入OPEN表
OPEN.add(new Node(num_Begin, 0, evaluateService.ReverseNumber(num_Begin), 0, null, 0));
//初始节点是否是目标节点？
if(isEqual(OPEN.get(0).num,num_Finish)){
String s = "-----第1步-----\n";
for (int k = 0; k < 3; ++k) {
for (int j = 0; j < 3; ++j) {
s += CLOSED.lastElement().num[k][j] + " ";
//最后一个元素的节点数据
result[0][k][j] = CLOSED.lastElement().num[k][j];
}
s += "\n";
}
s += "-----结束-----\\n";
info[0] = 0; // 移动步数
info[1] = System.nanoTime() - starTime;
return result;
}
while (!OPEN.isEmpty()) {
// 计算可达性,限制搜索深度
if (!isAvailable(OPEN.get(0).num,num_Finish) || OPEN.get(0).depth > MAX_SEARCH_DEPTH) {
return null;
}
CLOSED.add(OPEN.get(0));
OPEN.remove(0);
int i = 0, j = 0;
// 找到空格
for (int k = 0; k < 9; ++k) {
if (CLOSED.lastElement().num[k / 3][k % 3] == 0) {
i = k / 3;
j = k % 3;
break;
}
}
int dir = CLOSED.lastElement().direction, dep = CLOSED.lastElement().depth;
int a[][] = new int[3][3];
// 1 上
if (i != 0 && dir != 2) {
for (int m = 0; m < 3; ++m) {
for (int n = 0; n < 3; ++n) {
a[m][n] = CLOSED.lastElement().num[m][n];
}
}
a[i][j] = a[i - 1][j];
a[i - 1][j] = 0;
Node temp = new Node(a, dep + 1, evaluateService.ReverseNumber(a), 1, CLOSED.lastElement(), 0);
// 子节点是否是目标节点？
if (isEqual(temp.num,num_Finish)) {
return Route2(temp, info);
}
OPEN.add(temp);
}
//参照“1 上”，执行下、左、右三个方向的扩展
}
return null;
}【实验结果与分析】
一、执行逻辑
| 介绍 |
运行截图 |
|
初始化界面由九宫格的初始状态和目标状态、估值函数选择区、算法选择区、路径打印区、结果记录表组成。 |
|
|
打乱九宫格后，点击“全局择先”按钮，跳出confirm框，询问是否确定进行路径查找。 |
|
|
选择确定后，打印出初始状态到目标状态需要走的步数，显示在标签页内嵌的表格中。 |
|
|
刷新界面后数据会从数据库回显到表格中，三种算法、四种估值函数均可用 |
|
二、结果测试
| 信息 |
测试截图 |
| --测试用例1
全局择先 h1 10步 132ms |
|
| --测试用例2
全局择先 h2 10步 166ms |
|
| --测试用例3
A*搜索 h3 10步 319ms |
|
| --测试用例4
宽度优先 10步 655ms |
|
三、结果分析
从上面的对比结果来看可以得到以下的结果分析：
- 选取不同的估值函数，有时还是会得到相同的路径结果；
- A*搜素和全局择先的运行速度比较接近；
- 在初始状态和目标状态相同的情况下，宽度优先的效率低于两种启发式搜索算法，即全局择先和A*算法。
【总结】
现在是凌晨3点20，课设报告终于收尾了，回想这几天的课设制作，也确实是感想颇深。
我是上周四开始写课设的，第一天，当然是储备基础知识，像典型的A*算法，还有全局择先，宽度优先这些，都认真学了一遍。当然还构思了一下课设的思路，因为不限语言，不限技术，脑子里一大堆天马行空的想实现的东西，一开始设计是想对比三种算法的优劣+用深度学习的方法训练一下它去玩这个华容道，看看到底是跑出个什么东西，或者就是想做一个联网的平台，可以让用户自行在网站pk拼图速度，或是打乱让用户还原，比较看和三种算法相比，谁的还原步数少。还想了一个点子就是用户自行上传图片––>裁剪成九宫格的样子––>玩自定义拼图，但都碍于时间有限，就没做了。
当然，由于我目前为止主要学过的也是全栈开发，所以，在这次的课设中，最终呈现的效果，就是一个前后端交互的网页端系统了。
周五，写课设的第二天，想着把后端架子先搭好，结果一下是pom出问题，找半天发现是maven仓库路径写错了，一下又是springboot报错，找半天，然后对着重新敲一遍就又可以运行了，气得我肝疼。好不容易加载出Spring标标了，结果又因为tomcat配的是2.9.5以上版本，配高了它有些东西不认识，又得重新写配置，总而言之就是突然发现，从头搭一个Springboot项目，对经验不丰富的人确实挺困难的呐。
然后下午的时候，开始写逻辑，数据库如果做了实时回显的话，倒也不会显得我那张记录存储表那么没用，还是遇到了很玄学的问题，局部刷新不了+数据回显它只读第一次的，后面无法修改数据+reload整个界面又把我的路径给刷没了，所以最后这个问题就没解决了，后期有时间的话还是做成分页，elementui里倒是有个el-pagenation，今天试了绑定不了数据就没做了，下次有时间再试试。
总之，后端遇到的困难主要是搭框架，还有就是写算法逻辑的问题，估值函数还挺好写的，三个算法对着流程图敲就完了，但一开始设计的时候，图方便，设计的字符串输出，结果就是，前端写完之后，改的我肝疼。
分别测试了三种接口写法，一种是String直接打印结果的，非常丑，而且，不好裁。第二种是返回的三维数组，相当于是吧每种状态都存在了数组中，而每种状态本身就是个二维数组，但因为用了是数组，数组就肯定定长，定长没排满，结果就是一堆0，太心累了，找了一堆办法没裁好，最后想着，要不要就还是用Node存储Service层返回的结果，结果因为设计的问题，它递归了，嵌套了十几二十层，才能找到最里面的节点，前端拿到的json文件，一看，我是真束手无策。最后求助大佬，大佬用三维数组的那个接口，给我裁好了，但我还是追求界面美观，于是又花了一个多小时，把路径结果从直线存成了3x3的了。
然后第三天，周六，开始写前端。前端倒是没啥难点，九宫格是改的一个4x4华容道，把人家网页扒下来，把4x4的逻辑看明白之后改成3x3的了，改这个是真挺累的，4x4的逻辑都是n%4，n÷4，那3x3就是把4改成3？no，4x4的九宫格，可移动也是4个方向，直接改的话肯定是出问题的，逻辑就是一定要能大致看得懂。我主要是卡在了回退函数那里，他那写的是n*3-v啥的，心想，3？这还不对，结果就是，这个用来记录的是移动方向和步数，3x3方格中一共有8种移动方式，所以就是0-8，并且移动两格和移动一格，对plc的修改存在一个二倍关系的，所以swith到break的排序还有要求。不过还得是我，总算还是写出来了。
总之最后呈现的课设效果还算不错，美中不足就是，数据库到最后还是没做到实时回显，数据库在设计的时候缺乏对初始状态和终止状态的记录，and没写自定义拼图这个功能了，还有canvas实现自动还原或打乱九宫格这个功能其实也是有必要的，但也没写了。还有设计实体类的时候，忘屏蔽变量了，全public是非常不安全的做法。
但感觉自己写的还是可以的，这应该也是我再次挑战自我，3天一个Springboot项目，离全栈工程师又近了一步。并且，通过这次的课设，也学习到了贪心、启发式搜索等算法，相信这些都会给我未来的学习带来收获。
最后，课设做完了，感谢老师这学期的辛苦教导！