实验内容
- 对九宫重排问题,建立图的启发式搜索求解方法;
- 用A*算法求解九宫重排问题。
实验要求
3х3九宫棋盘,放置数码为1~8的8个棋子,棋盘中留有一个空格,空格周围的棋子可以移动到空格中,从而改变棋盘的布局。根据给定初始布局和目标布局,移动棋子从初始布局到达目标布局,求解移动步骤并输出。请设计算法,使用合适的搜索策略,在较少的空间和时间代价下找到最短路径。
编程语言的选择
- 编程语言:Java
- 编译环境:JDK1.8
- 开发工具:IntelliJ IDEA
项目思路
项目解析
(1)1-8八个数字随机分布在一个九宫格内
(2)九宫格内存在一个无数字格(称为空格),为方便计算,可用#代替
(3)空格周围的几个数字都可与空格互换位置
(4)经过多次互换,使得空格位于九宫格重要,数字1-8从左上角宫格开始,顺时针依次排布
(5)从初始状态经过多次互换达到最终状态有无数种可能,求最优算法
算法选择
A*算法
A* 算法,A*(A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法,也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近,最终搜索速度越快。
注意——是最有效的直接搜索算法,之后涌现了很多预处理算法(如ALT,CH,HL等等),在线查询效率是A*算法的数千甚至上万倍。
公式表示为:f(n)=g(n)+h(n),
其中, f(n) 是从初始状态经由状态n到目标状态的代价估计,
g(n)是在状态空间中从初始状态到状态n的实际代价,
h(n) 是从状态n到目标状态的最佳路径的估计代价。
(对于路径搜索问题,状态就是图中的节点,代价就是距离)
h(n)的选取保证找到最短路径(最优解的)条件,关键在于估价函数f(n)的选取(或者说h(n)的选取)。
我们以d(n)表达状态n到目标状态的距离,那么h(n)的选取大致有如下三种情况:
(1)如果h(n)<d(n)到目标状态的实际距离,这种情况下,搜索的点数多,搜索范围大,效率低。但能得到最优解。
(2)如果h(n)=d(n),即距离估计h(n)等于最短距离,那么搜索将严格沿着最短路径进行, 此时的搜索效率是最高的。
(3)如果h(n)>d(n),搜索的点数少,搜索范围小,效率高,但不能保证得到最优解。
代码实现如下:
public static int A_star(int[][] MT) {
// 找到空格所在的位置
int x0 = 0, y0 = 0;
for (x0 = 0; x0 < N; x0++) {
boolean flag = false;
for (y0 = 0; y0 < N; y0++) {
if (MT[x0][y0] == 0) {
flag = true;
break;
}
}
if (flag)
break;
}
// 优先队列
Queue<node> q = new PriorityQueue<node>(cmp);
int[][] curmt = new int[N][];
int[][] markemt = new int[N][];
// clone方法用于复制一个对象,在内存中开辟同样大小的空间
for (int r = 0; r < N; r++)
curmt[r] = MT[r].clone();
for (int r = 0; r < N; r++)
markemt[r] = MT[r].clone();
List<int[][]> path = new ArrayList<int[][]>();
// path加入初始状态
path.add(MT);
// 创建一个结点,表示空格,估价函数初始化为0
node cur = new node(x0, y0, 0, 0, 0, curmt, path);
// 将出现过的所有状态都加入marke集合中
marke.add(markemt);
// 入队并遍历
q.add(cur);
while (!q.isEmpty()) {
// 队首元素出队
cur = (node) q.poll().clone();
boolean tag = false;
// 判断当前状态是不是目标状态
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (cur.mt[i][j] != endMT[i][j]) {
tag = true;
}
}
}
// 如果是,输出结果
if (!tag) {
System.out.println("共扩展了" + marke.size() + "个结点");
return cur.step;
}
// 遍历四种方向上的移动
for (int i = 0; i < 4; i++) {
node next = (node) cur.clone();
next.x = cur.x + dir[i][0];
next.y = cur.y + dir[i][1];
// 如果空格位置不合法就忽略这个状态
if (next.x >= 0 && next.x < N && next.y >= 0 && next.y < N) {
// 因为上面next定义时clone了cur,所以在这里更新空格的位置
next.mt[cur.x][cur.y] = next.mt[next.x][next.y];
next.mt[next.x][next.y] = 0;
boolean mark = false;
// 判断当前状态有没有出现过
for (int c = 0; c < marke.size(); c++) {
int x = 0, y = 0;
for (x = 0; x < N; x++) {
for (y = 0; y < N; y++)
if (marke.get(c)[x][y] != next.mt[x][y])
break;
if (y < N)
break;
}
if (x == N && y == N)
mark = true;
}
// 若出现过则忽略这个状态
if (!mark) {
// 更新next的属性值step和估价函数g
next.step++;
next.g++;
// 将当前状态加入到结点的path中,因为程序中定义结点时,clone了上一个结点,所以在当前结点添加的状态也会clone到下一个结点中。
next.path.add(next.mt);
// 计算估价函数h,获取每个位置的数字,到达目标状态中对应数字的位置,所需要的步数
int count = 0;
for (int row = 0; row < N; row++) {
for (int cow = 0; cow < N; cow++) {
if (cow != 0 && next.mt[row][cow] != endMT[row][cow]) {
count += Math.abs(row - map.get(next.mt[row][cow])[0])
+ Math.abs(cow - map.get(next.mt[row][cow])[1]);
}
}
}
next.h = count;
// 将扩展状态入队
int[][] newmt = new int[N][];
for (int r = 0; r < N; r++)
newmt[r] = next.mt[r].clone();
marke.add(newmt);
q.add((node) next.clone());
}
}
}
}
return 0;
}