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

news2024/9/20 11:22:46

目录

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;
                }
            }
        });
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2051756.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

阶段练习——minishell

阶段练习——minishell

目录 &#xff08;一&#xff09;文件复制&#xff08;my_cp函数&#xff09; &#xff08;二&#xff09;文件内容查看&#xff08;my_cat函数&#xff09; &#xff08;三&#xff09;切换目录&#xff08;my_cd函数&#xff09; &#xff08;四&#xff09;列出目录内容…
阅读更多...
一款专为IntelliJ IDEA用户设计的插件，极大简化Spring项目中的API调试过程，功能强大（附源码）

一款专为IntelliJ IDEA用户设计的插件，极大简化Spring项目中的API调试过程，功能强大（附源码）

前言 在软件开发过程中&#xff0c;尤其是Spring MVC(Boot)项目中&#xff0c;API调试调用是一项常见但繁琐的任务。现有的开发工具虽然提供了一些支持&#xff0c;但往往存在效率不高、操作复杂等问题。为了处理这些痛点&#xff0c;提升开发效率&#xff0c;一款新的工具应运…
阅读更多...
python 捕获异常

python 捕获异常

捕获指定异常 e 是保存的异常信息 捕获多个异常
阅读更多...
快速体验fastllm安装部署并支持AMD ROCm推理加速

快速体验fastllm安装部署并支持AMD ROCm推理加速

序言 fastllm是纯c实现&#xff0c;无第三方依赖的高性能大模型推理库。 本文以国产海光DCU为例&#xff0c;在AMD ROCm平台下编译部署fastllm以实现LLMs模型推理加速。 测试平台&#xff1a;曙光超算互联网平台SCNet GPU/DCU&#xff1a;异构加速卡AI 显存64GB PCIE&#…
阅读更多...
Selenium + Python 自动化测试18（数据驱动实现测试）

Selenium + Python 自动化测试18（数据驱动实现测试）

我们的目标是&#xff1a;按照这一套资料学习下来&#xff0c;大家可以独立完成自动化测试的任务。 上一篇我们讨论了数据驱动测试中如何读取Excel文件&#xff0c;今天我们试着进一步深入学习数据驱动。 本篇文章我们讨论一下如何使用数据驱动思想实现测试。 1、数据驱动框架…
阅读更多...
从零开始学cv-5： 图像的仿射变换

从零开始学cv-5： 图像的仿射变换

文章目录 一&#xff0c;简介&#xff1a;二&#xff0c;图像仿射变换详解2.1&#xff0c;图像平移&#xff1a;2.2 &#xff0c;图像旋转&#xff1a;2.3&#xff0c;仿射变换&#xff1a; 一&#xff0c;简介&#xff1a; 仿射变换&#xff08;Affine Transformation 或 Aff…
阅读更多...
Lumina学术引擎免费问世，性能超谷歌学术5倍

Lumina学术引擎免费问世，性能超谷歌学术5倍

Lumina介绍 Lumina是一款完全免费的AI学术搜索引擎&#xff0c;借助强大的数据库和高效的匹配速度。利用超过 15 种模型从超过 100 万篇期刊文章中找出最相关的来源&#xff0c;从而构建答案。搜索结果相关性平均比谷歌学术高出5倍&#xff0c;支持超1亿研究对象搜索&#xff…
阅读更多...
8.18日学习打卡---Spring Cloud Alibaba（五）

8.18日学习打卡---Spring Cloud Alibaba（五）

8.18日学习打卡 目录&#xff1a; 8.18日学习打卡 RocketMQ什么是RocketMQ生产者和消费者技术架构 RocketMQ安装与配置环境搭建与测试RocketMQ管理命令 RocketMQ发送消息普通消息顺序消息之全局消息顺序消息之局部消息消费者消费消息延迟消息延迟消息代码实现单向消息批量消息过…
阅读更多...
【HarmonyOS】云开发-用户自动认证

【HarmonyOS】云开发-用户自动认证

背景 华为云服务提供了统一认证的云服务&#xff0c;支持手机、邮箱等自定义登录服务&#xff0c;并且提供了免费使用的额度&#xff0c;这样子方便中小企业或者项目快速的开发工作。下面是支持的认证方式&#xff1a; 操作步骤 1.AGC(AppGallery Connect)创建项目 在AGC界…
阅读更多...
C++ | Leetcode C++题解之第342题4的幂

C++ | Leetcode C++题解之第342题4的幂

题目&#xff1a; 题解&#xff1a; class Solution { public:bool isPowerOfFour(int n) {return n > 0 && (n & (n - 1)) 0 && n % 3 1;} };
阅读更多...
zabbix监控进程、日志、主从状态和主从延迟

zabbix监控进程、日志、主从状态和主从延迟

zabbix监控进程、日志、主从状态和主从延迟 监控进程1、下载服务2、编写脚本3、编写zabbix_agentd.conf4、新建监控项配置触发器5、查看邮件 监控日志1、上传log.py的2、编写zabbix_agentd.conf3、新建监控项配置触发器 监控数据库主从状态1、编写/etc/hosts&#xff08;master…
阅读更多...
IOS 09 R.swift框架和使用方法

IOS 09 R.swift框架和使用方法

R.swift框架主要是实现通过类字段访问字符串&#xff0c;图片&#xff0c;等资源&#xff1b;类似Android那边通过R类访问&#xff0c;好处是有提示&#xff0c;如果缺少资源&#xff0c;直接就是编译错误&#xff1b;OC类似的功能叫R.objc。 添加依赖 添加依赖 #将资源&…
阅读更多...
第八周：机器学习笔记

第八周：机器学习笔记

第八周机器学习笔记 摘要Abstract机器学习1. 鱼和熊掌和可兼得的机器学习1.1 Deep network v.s. Fat network 2. 为什么用来验证集结果还是不好&#xff1f; Pytorch学习1. 卷积层代码实战2. 最大池化层代码实战3. 非线性激活层代码实战 总结 摘要 本周学习对李宏毅机器学习视…
阅读更多...
AI学习记录 - Word2Vec 超详细解析

AI学习记录 - Word2Vec 超详细解析

创作不易&#xff0c;点个赞 我们有一堆文本&#xff0c;词汇拆分 sentences ["jack like dog", "jack like cat", "jack like animal","dog cat animal", "banana apple cat dog like", "dog fish milk like"…
阅读更多...
URP平面阴影合批处理 shadow

URP平面阴影合批处理 shadow

闲谈 相信大家在日常工作中发现了一个问题 &#xff0c; urp下虽然可以做到3个Pass 去写我们想要的效果&#xff0c;但是&#xff0c;不能合批&#xff08;不能合批&#xff0c;那不是我们CPU要干冒烟~&#xff01;&#xff09; 好家伙&#xff0c;熊猫老师的偏方来了 &#x…
阅读更多...
【数值方法-Python实现】Crout分解+追赶法实现

【数值方法-Python实现】Crout分解+追赶法实现

涉及Crout分解、追赶法的线性方程组求解方法的Python实现。 原文链接&#xff1a;https://www.cnblogs.com/aksoam/p/18366119 Codes def CroutLU(A:np.ndarray)->Tuple[np.ndarray,np.ndarray]:"""Crout LU分解算法,ALUinput:A: (n,n) np.ndarray,方阵out…
阅读更多...
DrissionPage自动化获取城市数据内容

DrissionPage自动化获取城市数据内容

一、获取页面内容 二、最终结果 上海市 约收录140个指标 查看98075次 人均GDP 153299元 公交车 17899辆 户籍人口 1469.3万人 三、代码 from DrissionPage._pages.chromium_page import ChromiumPage import time page ChromiumPage() page.get(https://www.swguancha.com/…
阅读更多...
【Delphi】中多显示器操作基本知识点

【Delphi】中多显示器操作基本知识点

提要&#xff1a; 目前随着计算机的发展&#xff0c;4K显示器已经逐步在普及&#xff0c;笔记本的显示器分辨率也都已经超过2K&#xff0c;多显示器更是普及速度很快。本文介绍下Delphi中操作多显示器的基本知识点&#xff08;Windows系统&#xff09;&#xff0c;这些知识点在…
阅读更多...
UniFab 是一款由人工智慧驅動的視訊增強器+ crack

UniFab 是一款由人工智慧驅動的視訊增強器+ crack

UniFab 是一款功能强大的视频处理工具，包括 10 个基于 AI 的功能。使用 UniFab，您可以提高视频和音频质量、将视频转换为不同的格式、根据自己的喜好编辑视频等等。以下是适用于 Windows 的 UniFab 程序的简要说明： 视频转换器。UniFab 支持 1000 多种视频格式的转换，包括 …
阅读更多...
构建自己的图数据集

构建自己的图数据集

代码&#xff1a; import warnings warnings.filterwarnings("ignore") import torch from torch_geometric.data import Datax torch.tensor([[2,1],[5,6],[3,7],[12,0]],dtypetorch.float) y torch.tensor([0,1,0,1],dtypetorch.float)#定义边 edge_index torc…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023