算法——马踏棋盘算法（骑士周游问题）/图的深度优先遍历+贪心算法优化

马踏棋盘问题的介绍

马踏棋盘算法也叫骑士周游问题，其要求是：将马随机放在国际象棋的 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秒，速度非常快。