十大常用算法之马踏棋盘算法

十大常用算法的完整实现

一、二分查找算法：https://blog.csdn.net/weixin_46635575/article/details/121532149
二、分治算法：https://blog.csdn.net/weixin_46635575/article/details/121532941
三、动态规划算法：https://blog.csdn.net/weixin_46635575/article/details/121534074
四、KMP算法：https://blog.csdn.net/weixin_46635575/article/details/121590510
五、贪心算法：https://blog.csdn.net/weixin_46635575/article/details/121626626
六、普利姆算法：https://blog.csdn.net/weixin_46635575/article/details/121653256
七、克鲁斯卡尔算法：https://blog.csdn.net/weixin_46635575/article/details/121670374
八、地杰斯特拉算法：https://blog.csdn.net/weixin_46635575/article/details/121692675
九、佛洛依德算法：https://blog.csdn.net/weixin_46635575/article/details/121714678
十、马踏棋盘算法（周游骑士算法）：https://blog.csdn.net/weixin_46635575/article/details/121716596

1、基本介绍

（1）马踏棋盘算法介绍

（2）实现马踏棋盘（周游骑士）的思路

首先要理解它的目的是：马走日字的问题，然后看你走的步数多少

2、代码实现

首先把这张图记心中【然后就跟着下面的一步步看】
本次代码的实现有如下
- 先去实现步骤3判断那个位置可以走通，那个走不通，这时候要记住上面这张图
- 然后再来创建数组来标记棋盘各个位置是否被访问过，实现周游骑士算法

（1）判断能走的格子

首先去看变量的创建
然后再来看我们next方法的实现


import java.awt.*;
import java.util.ArrayList;public class HorseDemo {/*   第一步定义的两个变量   */private static int X;//表示棋盘的列private static int Y;//表示棋盘的行public static void main(String[] args) {}/*** 方法一：根据当前位置（Point对象），计算马儿还能走到哪些位置（Point对象），并放到一个集合中（ArrayList，最多八个位置* Point是java的一个类，表示一个个点* @param curPoint* @return*/public static ArrayList<Point> next(Point curPoint) {//创建一个ArrayListArrayList<Point> ps = new ArrayList<>();//创建Point对象Point p1 = new Point();//这下面的是什么意思呢？//p1.x = curPoint.x - 2将当前点往左边移动两列，到M列//p1.y = curPoint.y -1 将当前点往上边移动一行，到N行//上面两个都满足的情况下，说名N和M的交界处可以走//这种情况先判断马儿可以走5这个位置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这个位置//这种情况是小于X的原因是：不能让它一直往右边走，直接走出去了撒//往右边走就是加1if ((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;}
}

（2）算法实现

对第一步分了解后，那接下来可以继续往下面看了
首先同样去看变量的创建
然后再去看方法二的实现

package cn.mldn.horse;import java.awt.*;
import java.util.ArrayList;public class HorseDemo {/*   第一步定义的两个变量   */private static int X;//表示棋盘的列private static int Y;//表示棋盘的行/*   第二步定义的两个变量   *///创建一个数组，标记棋盘的各个位置是否被访问过private static boolean visited[];//使用一个属性来标记是否棋盘的所有位置都被访问过了【也就是是否成功了】private static boolean finished;//为true就是已经成功了public static void main(String[] args) {X = 6;Y = 6;int row = 1;//马儿初始位置的行，从1开始编号int column = 1;//马儿位置的列，从1开始编号//创建棋盘int[][] chessboard = new int[X][Y];visited = new boolean[X * Y];//初始值为false//输出一下棋盘便于观察for (int[] rows: chessboard) {for (int step: rows) {System.out.print(step + " ");}System.out.println();}//测试一下耗时long start = System.currentTimeMillis();traversalChessBoard(chessboard,row - 1, column - 1,1);long end = System.currentTimeMillis();System.out.println("共耗时" + (end - start));//输出一下棋盘的情况for (int[] rows: chessboard) {for (int step: rows) {System.out.print(step + " ");}System.out.println();}}/*** 方法一：根据当前位置（Point对象），计算马儿还能走到哪些位置（Point对象），并放到一个集合中（ArrayList，最多八个位置* Point是java的一个类，表示一个个点* @param curPoint* @return*/public static ArrayList<Point> next(Point curPoint) {//创建一个ArrayListArrayList<Point> ps = new ArrayList<>();//创建Point对象Point p1 = new Point();//这下面的是什么意思呢？//p1.x = curPoint.x - 2将当前点往左边移动两列，到M列//p1.y = curPoint.y -1 将当前点往上边移动一行，到N行//上面两个都满足的情况下，说名N和M的交界处可以走//这种情况先判断马儿可以走5这个位置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这个位置//这种情况是小于X的原因是：不能让它一直往右边走，直接走出去了撒//往右边走就是加1if ((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;}/*** 方法二* 算法实现【其实周游的算法实现* @param chessboard 棋盘* @param row 马儿当前的位置的行，从0开始记* @param column 马儿当前位置的列，从0开始记* @param step 是第几步了，初始位置就是第一步，下一步就是第二步了*/public static void traversalChessBoard(int[][] chessboard,int row,int column,int step) {chessboard[row][column] = step;//将当前点标记为已访问【row * X + column的意思你可以算一下，以我们的来看一下，row是4，X=8，column = 4 你的当前点在visited里面的位置就是36visited[row * X + column] = true;//获取当前位置可以走的下一个位置的集合ArrayList<Point> ps = next(new Point(column, row));//开始遍历【判断是否可以走】while (!ps.isEmpty()) {//ps.isEmpty()说明没有遍历完Point p = ps.remove(0);//取出下一个可以走的位置//判断该点是否已经访问过了if (!visited[p.y * X + p.x]) {//如果visited[p.x * X + p.x]，说明被访问了//然后就去递归了traversalChessBoard(chessboard, p.y, p.x, step + 1);}}//判断马儿是否完成了这个步骤，如果没有完成就置0if (step < (X * Y) && !finished) {//step < X * Y说明还没有走完，并且finished没有走完的情况下chessboard[row][column] = 0;//因为之前我们是假设这么row * X + column一个点是可以走通的，但是实际上不能走通，所以要进行回溯visited[row * X + column] = false;} else {//如果step < X * Y 为真，并且finished为false的情况下，说明//直接将finished置为true就可以了finished = true;}}
}

（3）用贪心算法进行优化我们的马踏棋盘算法

可能拿去执行的朋友都会发现启动这算法，发现仅仅是才6*6就运行了很长的时间，所以进行优化一下。

认真看下来会发现，在算法的实现方法里面有一个回溯的过程，这个是造成我们算法用的时间很多的原因所在，解决办法如下

首先去看我们的sort方法
然后再去看我们的算法里面的修改【就修改了两句话】

import java.awt.*;
import java.util.ArrayList;
import java.util.Comparator;public class HorseDemo {/*   第一步定义的两个变量   */private static int X;//表示棋盘的列private static int Y;//表示棋盘的行/*   第二步定义的两个变量   *///创建一个数组，标记棋盘的各个位置是否被访问过private static boolean visited[];//使用一个属性来标记是否棋盘的所有位置都被访问过了【也就是是否成功了】private static boolean finished;//为true就是已经成功了public static void main(String[] args) {X = 8;Y = 8;int row = 1;//马儿初始位置的行，从1开始编号int column = 1;//马儿位置的列，从1开始编号//创建棋盘int[][] chessboard = new int[X][Y];visited = new boolean[X * Y];//初始值为false//输出一下棋盘便于观察for (int[] rows: chessboard) {for (int step: rows) {System.out.print(step + " ");}System.out.println();}//测试一下耗时long start = System.currentTimeMillis();traversalChessBoard(chessboard,row - 1, column - 1,1);long end = System.currentTimeMillis();System.out.println("共耗时" + (end - start));//输出一下棋盘的情况for (int[] rows: chessboard) {for (int step: rows) {System.out.print(step + " ");}System.out.println();}}/*** 方法一：根据当前位置（Point对象），计算马儿还能走到哪些位置（Point对象），并放到一个集合中（ArrayList，最多八个位置* Point是java的一个类，表示一个个点* @param curPoint* @return*/public static ArrayList<Point> next(Point curPoint) {//创建一个ArrayListArrayList<Point> ps = new ArrayList<>();//创建Point对象Point p1 = new Point();//这下面的是什么意思呢？//p1.x = curPoint.x - 2将当前点往左边移动两列，到M列//p1.y = curPoint.y -1 将当前点往上边移动一行，到N行//上面两个都满足的情况下，说名N和M的交界处可以走//这种情况先判断马儿可以走5这个位置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这个位置//这种情况是小于X的原因是：不能让它一直往右边走，直接走出去了撒//往右边走就是加1if ((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;}/*** 算法实现【其实周游的算法实现* @param chessboard 棋盘* @param row 马儿当前的位置的行，从0开始记* @param column 马儿当前位置的列，从0开始记* @param step 是第几步了，初始位置就是第一步，下一步就是第二步了*/public static void traversalChessBoard(int[][] chessboard,int row,int column,int step) {chessboard[row][column] = step;//将当前点标记为已访问【row * X + column的意思你可以算一下，以我们的来看一下，row是4，X=8，column = 4 你的当前点在visited里面的位置就是36visited[row * X + column] = true;//获取当前位置可以走的下一个位置的集合ArrayList<Point> ps = next(new Point(column, row));//新添的//对ps进行排序【即对ps里面的元素下一步的位置的数目进行非递减排序】sort(ps);//开始遍历【判断是否可以走】while (!ps.isEmpty()) {//ps.isEmpty()说明没有遍历完Point p = ps.remove(0);//取出下一个可以走的位置//判断该点是否已经访问过了if (!visited[p.y * X + p.x]) {//如果visited[p.x * X + p.x]，说明被访问了//然后就去递归了traversalChessBoard(chessboard, p.y, p.x, step + 1);}}//判断马儿是否完成了这个步骤，如果没有完成就置0if (step < (X * Y) && !finished) {//step < X * Y说明还没有走完，并且finished没有走完的情况下chessboard[row][column] = 0;//因为之前我们是假设这么row * X + column一个点是可以走通的，但是实际上不能走通，所以要进行回溯visited[row * X + column] = false;} else {//如果step < X * Y 为真，并且finished为false的情况下，说明//直接将finished置为true就可以了finished = true;}}//根据当前这一步的所有的下一步的选择位置，进行非递减排序，减少回溯的次数public static void sort(ArrayList<Point> ps) {ps.sort(new Comparator<Point>() {@Overridepublic 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;}}});}
}