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

最新推荐文章于 2024-05-29 18:58:23 发布
最新推荐文章于 2024-05-29 18:58:23 发布
阅读量1k 收藏 5
点赞数
分类专栏： # 算法笔记 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46635575/article/details/121716596
版权

十大常用算法的完整实现

一、二分查找算法：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) {
        //创建一个ArrayList
        ArrayList<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的原因是：不能让它一直往右边走，直接走出去了撒
            //往右边走就是加1
        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;
    }
}

（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) {
        //创建一个ArrayList
        ArrayList<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的原因是：不能让它一直往右边走，直接走出去了撒
            //往右边走就是加1
        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;
    }

    /**
     * 方法二
     * 算法实现【其实周游的算法实现
     * @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里面的位置就是36
        visited[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);
            }
        }
        //判断马儿是否完成了这个步骤，如果没有完成就置0
        if (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) {
        //创建一个ArrayList
        ArrayList<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的原因是：不能让它一直往右边走，直接走出去了撒
            //往右边走就是加1
        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;
    }

    /**
     * 算法实现【其实周游的算法实现
     * @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里面的位置就是36
        visited[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);
            }
        }
        //判断马儿是否完成了这个步骤，如果没有完成就置0
        if (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>() {
            @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
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于贪心算法的马踏棋盘哈密顿回路问题
11-26
1. 通过贪心算法对可以回到起点的环游解——哈密顿回路 进行了优化。当棋盘规模小于12时，能够迅速给出任意一个节点的一条哈密顿解 2. 若不要求回到起点最大规模可达60 3. 可以自定义是否回到起点，棋盘规模以及是否...
数据结构之马踏棋盘具体算法实现
12-17
"数据结构之马踏棋盘具体算法实现" 在计算机科学中，马踏棋盘问题是一个经典的算法问题。该问题的目的是让马在棋盘上遍历所有格子，而不重复踏入任何一个格子。这个问题可以用来考察算法设计和数据结构的应用。本文...
马踏棋盘（回溯算法）——十大算法
ALin_Think的博客
04-03 2210
马踏棋盘问题 回溯算法 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。 回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。 问题基本介绍 1、马踏棋盘算法...
算法——马踏棋盘算法（骑士周游问题）/图的深度优先遍历+贪心算法优化
weixin_43713707的博客
04-13 614
马踏棋盘算法也叫骑士周游问题，其要求是：将马随机放在国际象棋的 8×8 棋盘 Board[0～7][0～7]的某个方格中，马按走棋规则()进行移动。要求，走遍棋盘上全部 64 个方格。
马踏棋盘笔记+源码
最新发布
m0_71187513的博客
05-29 394
马踏棋盘，骑士周游笔记
算法：马踏棋盘算法
lsh199196的专栏
02-14 1465
在图中寻找哈密尔顿路径。 定义：将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格。 算法：如图： 马踏棋盘的一个点：对于n*n的棋盘上，当n》=5且为偶数的情况下，以任意点都有解。 一些相关的知识： 1、回溯法 思想很简单，一条路走到黑，碰壁了再回来一条路走到黑，一
数据结构与算法（Java版） | 几个经典的算法面试题（下）
李阿昀的博客
12-08 681
上一讲，我给大家介绍了两个经典算法面试题，即字符串匹配问题和汉诺塔游戏，这一讲，我再来给大家介绍两个经典算法面试题，它们就是八皇后问题和马踏棋盘算法，注意，马踏棋盘算法也被称为骑士周游问题哟！接下来，我就先来给大家介绍一下八皇后问题这个经典算法面试题吧！
数据结构栈的使用——马踏棋盘
m0_61886762的博客
09-29 1285
在函数中首先判断马有没有将棋盘走完，如果走完了则在其中将判断变量值设置为1，且定义一个次数变量，加一个循环其停止条件则是该栈为空，当栈一直不为空时则让一个结构体存储栈顶的数据，然后进行退栈操作随后将map中的栈顶位置存储为最后一个位置，依次类推存储马走的位置。如果马没有将棋盘走完则让马的当前位置判断周围的八个点是否可以走，如果可以走则标记该点已走过然后将数据存入栈中，如果走不了则继续进行循环直到八个点都不可以走之后则将栈元素退出然后标记值设置为0，再次调用该函数让马继续走。
马踏棋盘（回溯算法）
通往神秘的道路的专栏
09-16 2328
题目 在n*m的棋盘中，马只能走"日"字。马从位置(x,y)出发，把棋盘的每一格都走一次且只走一次。找出所有路径。 分析 马是在棋盘的点上行走的，所以这里的棋盘是指行有N条边、列有M条边。而一个马在不出边界的情况下有8个方向可以行走(走"日"字)，如当前坐标为(x,y)，则行走后的坐标可以为: (x+1, y+2) (x+1, y-2) (x+2, ...
马踏棋盘问题（C语言）——基于贪心算法优化的深度优先搜索
03-30
马踏棋盘问题（骑士巡游问题）的基于贪心算法优化深度搜索可视化实现 用c语言实现的，在命令台中会动态的显示棋盘上棋子路径
马踏棋盘非递归算法.doc
05-08
马踏棋盘非递归算法 马踏棋盘问题是计算机科学中一个经典的问题，它是指用马从棋盘上的某个位置出发，可以访问棋盘上的所有位置，并且每个位置只能访问一次。马踏棋盘非递归算法是一种解决该问题的方法，它使用栈...
java-马踏棋盘（最优算法）
11-11
完全可以直接提交的马踏棋盘设计报告，输入是控制台输入
马踏棋盘与八皇后问题
01-01
使用数据结构解决马踏棋盘与八皇后问题，做课程设计时正好想起来，希望能对其他人有帮助
马踏棋盘算法（c++）
12-12
贪心算法，回溯法，哈密尔顿路径，马踏棋盘算法练习，
马踏棋盘的贪心算法实现
10-24
综上所述，"马踏棋盘的贪心算法实现"是一个结合了数据结构（如优先队列）、算法设计（贪心策略）和图形界面编程的综合实践项目。通过这个项目，不仅可以深入理解贪心算法的工作原理，还可以提升在VC++环境下解决问题...
马踏棋盘问题(贪心算法实现C++)
u013177138的博客
12-01 1767
算法实现流程： 步骤1：初始化马的位置（结构体horse {x, y}） 步骤2：确定马从当前点出发，可跳跃的附近8个点，以结构体Jump数组给出，但需判断当前给出的附近8个点是否曾经访问过，或者是否这8个点超出棋盘尺寸。 步骤3：跟据步骤2确定跳跃的点，分别计算可跳跃点的下下一步，可跳跃点的个数。并选出下下步可跳跃点数最少的点作为马下一步跳跃的点。（举例说明：马当前所在点坐标（4，4），下一步可跳跃点有（5，2），（6，3），且（5，2）下一步可跳跃点有3个，（6，3）下一步可跳跃点2个；3 &..
【理解】算法：chessboard covering with trominoes
ToBeAMensch
07-23 473
嘿嘿，trominoes其实就是L型拼图。今天又来说一个递归。出处是Python Algorithms，第三章，大概九十几页的地方。 这个算法试图解决，国际象棋棋盘用L型拼图拼接。其实最后还是会有个角缺着的，如图，一般会先把这个缺掉的格子定义好。 这似乎看起来有点难度...于是伟大的人类再次尝试采用divide and conquer化解，然后就成功了。。。 借高中数学老师的话说

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值