马踏棋盘问题的介绍
马踏棋盘算法也叫骑士周游问题,其要求是:将马随机放在国际象棋的 8×8 棋盘 Board[0~7][0~7]的某个方格中,马按走棋规则(马走日字)进行移动。要求每个方格只进入一次,走遍棋盘上全部 64 个方格。
算法分析
思路
1) 马踏棋盘问题(骑士周游问题)实际上是图的深度优先搜索(DFS)的应用。
2) 如果使用回溯(就是深度优先搜索)来解决,假如马儿踏了 53 个点,如图:走到了第 53 个,坐标(1,0),发现已经走到尽头,没办法,那就只能回退了,查看其他的路径,就在棋盘上不停的回溯……
图解
上述算法的思路图解如下:
代码实现
代码如下:
package com.study.horse;
import java.awt.*;
import java.util.ArrayList;
/**
* @author 漂亮小小
* @version 1.0
*/
public class HorseChessBoard {
private static int X;//列数
private static int Y;//行数
//创建一个数组,标记棋盘的各个位置是否被访问过
private static boolean[] visited;
//使用一个属性,标记棋盘的所有位置是否都被访问过了,即:是否成功 true代表成功
private static boolean finished = false;
public static void main(String[] args) {
//c测试
X = 8;
Y = 8;
int row = 1;//马儿的初始位置的行 从1开始编号
int colum = 1;//马儿的初始位置的列 从1开始编号
//创建棋盘
int[][] chessboard = new int[X][Y];
visited = new boolean[X * Y];
//测试耗时
long start = System.currentTimeMillis();//开始时间
//调用方法
traversalChessBoard(chessboard, row - 1, colum - 1, 1);
long end = System.currentTimeMillis();
System.out.println("程序用时:" + (end - start) + "毫秒");
//输出棋盘的遍历情况
for (int[] rows : chessboard) {
for (int step : rows) {
System.out.print(step + "\t");
}
System.out.println();
}
}
//方法:马踏棋盘核心算法
/**
* 骑士周游问题的算法
*
* @param chessboard 棋盘
* @param row 马儿当前位置的第几行 从0 开始
* @param column 马儿当前位置的第几列 从0开始
* @param step 是第几步 初始位置就是第一步 以后每次+1
*/
public static void traversalChessBoard(int[][] chessboard, int row, int column, int step) {
chessboard[row][column] = step;
visited[row * X + column] = true;//表示第row * X + column个格子被走了,当前位置标记已访问
//获取当前位置可以走的下一个位置的集合
ArrayList<Point> ps = next(new Point(column, row));
//遍历ps
while (!ps.isEmpty()) {
Point p = ps.remove(0);//取出下一个可以走的位置
//判断该点是否已经访问过了
if (!visited[p.y * X + p.x]) {
traversalChessBoard(chessboard, p.y, p.x, step + 1);
}
}
//判断马儿是否完成了任务
//step < X * Y成立的情况:1.棋盘到目前为止,仍然没有走完
// 2.棋盘处于回溯过程
if (step < X * Y && !finished) {
chessboard[row][column] = 0;
visited[row * X + column] = false;
} else {
finished = true;
}
}
/**
* 功能:根据当前位置(Point对象),计算马儿还能走哪些位置(Point),并放入到一个集合(ArrayList)中,最多有8个位置
*
* @param curPoint 当前位置
* @return 还能走的位置的集合
*/
public static ArrayList<Point> next(Point curPoint) {
//创建一个ArrayList
ArrayList<Point> ps = new ArrayList<>();//存放所有可以走的位置点
//创建Point
Point p1 = new Point();//存放 待选择的下一个位置
//p1.x = curPoint.x - 2 当前点向左移动2格,
// p1.y = curPoint.y - 1当前点向右移动1格
//也就是棋盘上当前位置的左上 5 这个位置 可以走通,就把这个p1点 加到集合中
if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y - 1) >= 0) {
ps.add(new Point(p1));
}
//判断马儿是否可以走6
if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y - 2) >= 0) {
ps.add(new Point(p1));
}
//判断马儿是否可以走7
if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
ps.add(new Point(p1));
}
//判断马儿是否可以走0
if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y - 1) >= 0) {
ps.add(new Point(p1));
}
//判断马儿是否可以走1
if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
ps.add(new Point(p1));
}
//判断马儿是否可以走2
if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
ps.add(new Point(p1));
}
//判断马儿是否可以走3
if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
ps.add(new Point(p1));
}
//判断马儿是否可以走4
if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
ps.add(new Point(p1));
}
return ps;//返回ps,里面装的是所有可以走的点
}
}
运行结果:
可以看到,运行时间很长,需要37秒左右,性能不是很高效,因此后面采用贪心算法进行优化。
马踏棋盘算法优化——贪心算法
优化思路
1.在获取到当前位置可以走的下一个位置的集合(下一步所有可以走的点)后:
2.对可走的集合ps中的所有的Point的下一步的所有集合的数目,进行非递减排序。这就是贪心算法思想。
补充:非递减是什么
递减排序:9,7,6,5,3,2,1.从大到小
递增排序:1,3,4,6,7,8,9.从小到大
非递减排序:1,2,3,3,3,4,5.从小到大,且允许有重复数字(递增过程中允许有重复值)
非递增排序:9,8,8,7,3,3,2.从大到小,且允许有重复数字(递减过程中允许有重复值)
优化代码
汇总:对优化后的代码进行展示如下:
package com.study.horse;
import java.awt.*;
import java.util.ArrayList;
import java.util.Comparator;
/**
* @author 漂亮小小
* @version 1.0
*/
public class HorseChessBoard {
private static int X;//列数
private static int Y;//行数
//创建一个数组,标记棋盘的各个位置是否被访问过
private static boolean[] visited;
//使用一个属性,标记棋盘的所有位置是否都被访问过了,即:是否成功 true代表成功
private static boolean finished = false;
public static void main(String[] args) {
//c测试
X = 8;
Y = 8;
int row = 1;//马儿的初始位置的行 从1开始编号
int colum = 1;//马儿的初始位置的列 从1开始编号
//创建棋盘
int[][] chessboard = new int[X][Y];
visited = new boolean[X * Y];
//测试耗时
long start = System.currentTimeMillis();//开始时间
//调用方法
traversalChessBoard(chessboard, row - 1, colum - 1, 1);
long end = System.currentTimeMillis();
System.out.println("程序用时:" + (end - start) + "毫秒");
//输出棋盘的遍历情况
for (int[] rows : chessboard) {
for (int step : rows) {
System.out.print(step + "\t");
}
System.out.println();
}
}
//方法:马踏棋盘核心算法
/**
* 骑士周游问题的算法
*
* @param chessboard 棋盘
* @param row 马儿当前位置的第几行 从0 开始
* @param column 马儿当前位置的第几列 从0开始
* @param step 是第几步 初始位置就是第一步 以后每次+1
*/
public static void traversalChessBoard(int[][] chessboard, int row, int column, int step) {
chessboard[row][column] = step;
visited[row * X + column] = true;//表示第row * X + column个格子被走了,当前位置标记已访问
//获取当前位置可以走的下一个位置的集合
ArrayList<Point> ps = next(new Point(column, row));//当前点 可以走的下一个点都有
//对ps进行排序,对ps的所有点对象的下一步的位置的数目,进行非递减排序
sort(ps);
//遍历ps
while (!ps.isEmpty()) {
Point p = ps.remove(0);//取出下一个可以走的位置
//判断该点是否已经访问过了
if (!visited[p.y * X + p.x]) {
traversalChessBoard(chessboard, p.y, p.x, step + 1);
}
}
//判断马儿是否完成了任务
//step < X * Y成立的情况:1.棋盘到目前为止,仍然没有走完
// 2.棋盘处于回溯过程
if (step < X * Y && !finished) {
chessboard[row][column] = 0;
visited[row * X + column] = false;
} else {
finished = true;
}
}
/**
* 功能:根据当前位置(Point对象),计算马儿还能走哪些位置(Point),并放入到一个集合(ArrayList)中,最多有8个位置
*
* @param curPoint 当前位置
* @return 还能走的位置的集合
*/
public static ArrayList<Point> next(Point curPoint) {
//创建一个ArrayList
ArrayList<Point> ps = new ArrayList<>();//存放所有可以走的位置点
//创建Point
Point p1 = new Point();//存放 待选择的下一个位置
//p1.x = curPoint.x - 2 当前点向左移动2格,
// p1.y = curPoint.y - 1当前点向右移动1格
//也就是棋盘上当前位置的左上 5 这个位置 可以走通,就把这个p1点 加到集合中
if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y - 1) >= 0) {
ps.add(new Point(p1));
}
//判断马儿是否可以走6
if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y - 2) >= 0) {
ps.add(new Point(p1));
}
//判断马儿是否可以走7
if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
ps.add(new Point(p1));
}
//判断马儿是否可以走0
if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y - 1) >= 0) {
ps.add(new Point(p1));
}
//判断马儿是否可以走1
if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
ps.add(new Point(p1));
}
//判断马儿是否可以走2
if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
ps.add(new Point(p1));
}
//判断马儿是否可以走3
if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
ps.add(new Point(p1));
}
//判断马儿是否可以走4
if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
ps.add(new Point(p1));
}
return ps;//返回ps,里面装的是所有可以走的点
}
//对当前这一步的所有的下一步可以选择的位置,进行非递减排序,减少回溯的可能
public static void sort(ArrayList<Point> ps) {
ps.sort(new Comparator<Point>() {
@Override
public int compare(Point o1, Point o2) {
//获取到o1的下一步的所有位置个数
int count1 = next(o1).size();
int count2 = next(o2).size();
if (count1 < count2) {
return -1;
} else if (count1 == count2) {
return 0;
}else {
return 1;
}
}
});
}
}
运行结果:
可以看到优化后的马踏棋盘算法,只需0.018秒,速度非常快。