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

马踏棋盘问题的介绍

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

  • 6
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值