【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化

最新推荐文章于 2024-08-18 18:02:49 发布
最新推荐文章于 2024-08-18 18:02:49 发布
阅读量339 收藏 4
点赞数 5
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_78914800/article/details/141287331
版权

目录

1.游戏规则

2.算法分析

3.解决步骤和思路

4.马踏棋盘算法的代码实现

4.1计算马儿还能走哪些位置

4.2马踏棋盘的核心代码

4.3马踏棋盘算法完整代码

4.4使用贪心算法进行优化

4.4.1思路

4.4.2代码实现 

1.游戏规则

将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。

2.算法分析

  1. 马踏棋盘（骑士周游）问题实际上是图的深度优先搜索（DFS）的应用
  2. 如果使用回溯（就是深度优先搜索）来解决，假如马儿踏了 53 个点，如图：走到了第 53 个，坐标 (1,0)，发现已经走到尽头，没办法，那就只能回退了。为了查看其他的路径，就在棋盘上不停的回溯
  3. 使用贪心算法进行优化

3.解决步骤和思路

  1. 创建棋盘 chessBoard，是一个二维数组
  2. 将当前位置设置为已经访问，然后根据当前位置，计算马儿还能走哪些位置，并放入到一个集合（ArrayList）中，最多有 8 个位置，每走一步，就让 step + 1
  3. 遍历 ArrayList 中存放的所有位置，看看哪个可以走通，如果走通就继续，走不通就回溯
  4. 判断马儿是否完成了任务，使用 step 和应该走的步数比较，如果没有达到数量，则表示没有完成任务，将整个棋盘置 0

注意：马儿不同的走法会得到不同的结果，效率也会有影响

4.马踏棋盘算法的代码实现

4.1计算马儿还能走哪些位置

public static ArrayList<Point> next(Point curPoint) {
        //创建一个 ArrayList
        ArrayList<Point> ps = new ArrayList<>();
        //创建一个 Point
        Point p1 = new Point();
        //左偏上
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        //上偏左
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        //上偏右
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        //右偏上
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        //右偏下
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        //下偏右
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //下偏左
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //左偏下
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        return ps;
    }

4.2马踏棋盘的核心代码

    /**
     * 完成马踏棋盘问题的算法
     * @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;  //标记该位置已经访问
        //获取当前位置可以走的下一个位置的集合
        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和应该走的步数比较
        如果没有达到数量，则表示没有完成任务，将整个棋盘置0
        说明：step < X * Y 成立的条件有两种
        1.棋盘到目前为止，仍然没有走完
        2.棋盘处于一个回溯过程
         */
        if (step < X * Y && !finished) {
            chessboard[row][column] = 0;
            visited[row * X + column] = false;
        } else {
            finished = true;
        }
    }

4.3马踏棋盘算法完整代码

public class HorseChessboard {
    private static int X;  //棋盘的列数
    private static int Y;  //棋盘的行数
    //创建一个数组，标记棋盘的各个位置是否被访问过
    private static boolean visited[];
    //使用一个属性，标记是否棋盘的所有位置都被访问
    private static boolean finished;  //如果为 true，表示成功

    public static void main(String[] args) {
        System.out.println("马踏棋盘算法开始运行");
        //测试马踏棋盘算法是否正确
        X = 8;
        Y = 8;
        int row = 1;  //马儿初始位置的行，从1开始编号
        int column = 1;  //马儿初始位置的列，从1开始编号
        //创建棋盘
        int[][] chessboard = new int[X][Y];
        visited = new boolean[X * Y];  //初始值都是false
        //测试一下耗时
        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 + "\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;  //标记该位置已经访问
        //获取当前位置可以走的下一个位置的集合
        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和应该走的步数比较
        如果没有达到数量，则表示没有完成任务，将整个棋盘置0
        说明：step < X * Y 成立的条件有两种
        1.棋盘到目前为止，仍然没有走完
        2.棋盘处于一个回溯过程
         */
        if (step < X * Y && !finished) {
            chessboard[row][column] = 0;
            visited[row * X + column] = false;
        } else {
            finished = true;
        }
    }

    public static ArrayList<Point> next(Point curPoint) {
        //创建一个 ArrayList
        ArrayList<Point> ps = new ArrayList<>();
        //创建一个 Point
        Point p1 = new Point();
        //左偏上
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        //上偏左
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        //上偏右
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        //右偏上
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        //右偏下
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        //下偏右
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //下偏左
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //左偏下
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        return ps;
    }
}

4.4使用贪心算法进行优化

4.4.1思路

  1. 获取当前位置的可以走的下一个位置的集合
  2. 对 ps 中所有的 Point 的下一步的所有集合的数目进行非递减排序

4.4.2代码实现 

public class HorseChessboard {
    private static int X;  //棋盘的列数
    private static int Y;  //棋盘的行数
    //创建一个数组，标记棋盘的各个位置是否被访问过
    private static boolean visited[];
    //使用一个属性，标记是否棋盘的所有位置都被访问
    private static boolean finished;  //如果为 true，表示成功

    public static void main(String[] args) {
        System.out.println("马踏棋盘算法开始运行");
        //测试马踏棋盘算法是否正确
        X = 8;
        Y = 8;
        int row = 1;  //马儿初始位置的行，从1开始编号
        int column = 1;  //马儿初始位置的列，从1开始编号
        //创建棋盘
        int[][] chessboard = new int[X][Y];
        visited = new boolean[X * Y];  //初始值都是false
        //测试一下耗时
        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 + "\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;  //标记该位置已经访问
        //获取当前位置可以走的下一个位置的集合
        ArrayList<Point> ps = next(new Point(column, row));
        //对 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和应该走的步数比较
        如果没有达到数量，则表示没有完成任务，将整个棋盘置0
        说明：step < X * Y 成立的条件有两种
        1.棋盘到目前为止，仍然没有走完
        2.棋盘处于一个回溯过程
         */
        if (step < X * Y && !finished) {
            chessboard[row][column] = 0;
            visited[row * X + column] = false;
        } else {
            finished = true;
        }
    }

    public static ArrayList<Point> next(Point curPoint) {
        //创建一个 ArrayList
        ArrayList<Point> ps = new ArrayList<>();
        //创建一个 Point
        Point p1 = new Point();
        //左偏上
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        //上偏左
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        //上偏右
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        //右偏上
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        //右偏下
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        //下偏右
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //下偏左
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //左偏下
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        return 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();
                //获取到 o2 的下一步的所有位置的个数
                int count2 = next(o2).size();
                if (count1 < count2) {
                    return -1;
                }else if (count1 == count2) {
                    return 0;
                } else {
                    return 1;
                }
            }
        });
    }
}
我想吃羊肉串
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
马踏棋盘算法（骑士周游问题）
Ronz 的博客
02-08 5208
一、问题概述 马踏棋盘算法也被称为骑士周游问题。问题内容是： 将马随机放在国际象棋的 8× 8 棋盘的某个方格中， 马按走棋规则（马走日字）进行移动。要求每个方格只能走一次， 走遍棋盘上全部 64 个方格，求可行的路径。 二、思路分析 马踏棋盘问题实际上是图的深度优先搜索（DFS）的应用。 该问题的解决思想为： 假设以 V 为起点，首先找出在指定规则下 V 点下一步可能的落点。 在下一步的可能的落点中选择一个点（假设是 U 点），然后走到 U 点。 再以 U 点为起点，找出指定规则下 U 点下一步可能的
马踏棋盘问题（C语言）——基于贪心算法优化的深度优先搜索
03-30
马踏棋盘问题（骑士巡游问题）的基于贪心算法优化深度搜索可视化实现 用c语言实现的，在命令台中会动态的显示棋盘上棋子路径
数据结构与算法 27 马踏棋盘 骑士周游 贪心算法优化
shake_shark_pp
06-25 310
马踏棋盘 代码实现思想 实际上是图的深度优先搜索（回溯） 创建棋盘 chessBoard，是一个二维数组 将当前位置设置为已经访问，然后根据当前位置，计算马儿还能走那些位置，并放入到一个集合中（ArrayList），最多有8个位置。每走一步，就 step+1 遍历ArrayList中存放的所有位置，看看哪个可以走通；如果走通，则继续；走不通，就回溯 判断马是否完成了任务 step 和应该走的步数（整个棋盘的格数-1）比较，如果没有达到数量，则表示没有完成任务，将整个棋盘置0 注意：马不同的走法会得到不同
【数据结构与算法】骑士周游算法/马踏棋盘算法的介绍和程序实现
Bulut0907
11-02 1129
将马随机放在国际象棋8×8棋盘的某个方格中，马按走棋规则(马走日字)不断的进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格(即移动63次)。如下所示为一个方格的马能移动的位置。
骑士周游问题（马踏棋盘）----贪心算法（动态规划补充）
Dr_RR的博客
05-28 732
然后就是考虑调用的位置 ：应该在获取ps数组下一个可以走的位置有哪些之后就对这些路线的数量进行排序，而其位置就在traversalChessBoard方法下，在对ps数组进行遍历之前进行排序。//这里一定要放入一个新的p1点，不然会造成p1点的位置一直在变换。比如：下一次走的1号位置和2号位置，1号位置的下一步有两个选择，2号位置下一步有四个选择，那马下一步就走1号位置以减少回溯次数。//这样就把ps数组里的每一个点的下一个位置的多少进行了排序，优先走下一步的下一步的次数少的格子。
马踏棋盘算法（骑士周游问题）——贪心算法优化
lu_long的博客
02-12 1352
骑士周游问题 在8x8的国际棋盘上，按照马走日的规则，验证是否能够走遍棋盘。 解题思路 创建棋盘 chessBoard，是一个二维数组。 将当前位置设置为已经访问，然后根据当前位置，计算马儿还能走哪些位置，并放入到一个集合中（ArrayList），最多有8个位置，每走一步，就使用step+1。 遍历ArrayList中存放的所有位置，看看哪个可以走通，如果走通，就继续，走不通，就回溯。 判...
基于python 的贪心算法解决8x8马踏棋盘问题并可视化
07-11
【作品名称】：基于贪心算法解决8x8马踏棋盘问题并可视化 【适用人群】：适用于希望学习不同技术领域的...- 介绍:运用贪心算法实现骑士周游问题，并用tkinter实现可视化 - 难度:简单 - pip install Image, pyautogui
马踏棋盘问题的可视化，运用贪心算法解决8x8的骑士周游问题.zip
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 一个可行性函数：用于确定候选项是否可以为解决方案做出贡献 一个目标函数...
基于贪心算法的马踏棋盘哈密顿回路问题
11-26
1. 通过贪心算法对可以回到起点的环游解——哈密顿回路 进行了优化。当棋盘规模小于12时，能够迅速给出任意一个节点的一条哈密顿解 2. 若不要求回到起点最大规模可达60 3. 可以自定义是否回到起点，棋盘规模以及是否...
马踏棋盘的贪心算法实现
10-24
在马踏棋盘问题中，贪心算法可能的具体实现步骤如下： 1. **初始化**：设定一个空的访问数组，用来标记棋盘上的每个格子是否已被马访问过。同时，定义起点，通常为棋盘的左上角，并标记为已访问。 2. **贪心策略**...
算法的学习笔记—删除链表中重复的结点（牛客JZ76）
业精于勤，荒于嬉
08-14 1226
本文介绍了一种删除排序链表中重复节点的高效算法。通过递归的方式，算法能够有效地删除所有重复节点，并保留链表中仅出现一次的节点。此方法的实现简单且易于理解，同时在时间和空间复杂度方面表现优异，适用于处理大规模数据链表中的重复节点问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 1156
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
C语言——函数递归
最新发布
2406_83392683的博客
08-18 211
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
noip2001数的划分
no_play_no_games的博客
08-18 64
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。例如：n=7，k=3，下面三种分法被认为是相同的。1，1，5;1，5，1;5，1，1;问有多少种不同的分法。
算法之递归和迭代
qq_28576837的博客
08-16 316
斐波那契数列（Fibonacci sequence），又称黄金分割数列，这个数列最早是由印度数学家提出来的。如果是用迭代，那么就是用循环从前往后计算，前两个数是固定的，先根据前两个数可以计算出第三个数，然后把第三个数和第二个数再赋值给之前的变量，再相加即可。使用递归时，如果要计算第100个数，那么要先直到第99和第98个，要知道第99个和第98个，就要分别进行递归，直到最后一层，再返回递归回来进行计算。这个序列的前几项是这样的：0,1,1,2,3,5,8,13,21,34,⋯。自然，用递归函数最容易实现。
24/8/18算法笔记 目标导向强化学习
yyyy2711的博客
08-18 228
初始化DDPG模型data = {'over':[],#Data采样函数#采样结果sample = {'over':[],#采样N个数据#随机一局游戏#随机游戏中的一步，这里除了最后一步#提取数据#设置fake goal#随机选择step后面的某一步#以后面某个步的状态为一个伪的终点，也就是希望先走到这里再说#求二范数mod = [#再自己重新计算reward和over#以伪终点构建新的state#计算最后10个数据reward_sum的值。
二分查找5️⃣-山脉数组的封顶索引
2202_75331338的博客
08-15 272
对于山峰来说，我们会发现封顶的值是最大，对于封顶左边来说，后一个数比前一个数大；◦ 如果 mid 位置呈现上升趋势，说明我们接下来要在 [mid + 1, right] 区间继续搜索；◦ 如果 mid 位置呈现下降趋势，说明我们接下来要在 [left, mid - 1] 区间搜索；◦ 因此，我们可以遍历数组内的每一个元素，找到某一个元素比两边的元素大即可。本题的数组不是有序数组，但我们依然可以使用二分查找，原因是因为我们发现了。输入：arr = [0,2,1,0]◦ 峰顶的特点：比两侧的元素都要大。
算法笔记：空间填充曲线
qq_40206371的博客
08-17 166
六次迭代的希尔伯特曲线：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值