马踏棋盘算法（使用贪心算法优化的前后对比）

最新推荐文章于 2021-02-08 09:12:41 发布
最新推荐文章于 2021-02-08 09:12:41 发布
阅读量1.4k 收藏 6
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fyj13925475957/article/details/104836947
版权

马踏棋盘算法介绍

  1. 马踏棋盘算法也被称为骑士周游问题
  2. 将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格
    在这里插入图片描述

马踏棋盘游戏代码实现分析

  1. 马踏棋盘问题(骑士周游问题)实际上是图的深度优先搜索(DFS)的应用。

  2. 如果使用回溯（就是深度优先搜索）来解决，假如马儿踏了53个点，如图：走到了第53个，坐标（1,0），发现已经走到尽头，没办法，那就只能回退了，查看其他的路径，就在棋盘上不停的回溯…… ，

在这里插入图片描述
代码示例

没有优化前的代码：

/**
 * 马踏棋盘算法
 */
public class HorseChessboard {
    // 棋盘
    private int[][] chessbord;
    // 标记对应的位置是否被访问过，总的大小 = 棋盘的 X*Y, 8*8 = 64
    private boolean[] visited;
    // 记录走的部数
    private int step;
    //使用一个属性，标记是否棋盘的所有位置都被访问
    private static boolean finished; // 如果为true,表示成功

    public HorseChessboard(int[][] chessbord) {
        this.chessbord = chessbord;
        visited = new boolean[chessbord.length * chessbord[0].length];
    }

    public void show() {
        System.out.println("走的步数：" + step);
        for (int[] ints : chessbord) {
            System.out.println(Arrays.toString(ints));
        }
    }

    /**
     * 完成骑士周游问题
     * @param rom 骑士开始的走 第几行
     * @param column 骑士开始的走 第几列
     */
    public void traversalChessboard(int rom, int column, int step) {
        // 记录该位置被访问
        visited[rom * chessbord[0].length + column] = true;
        // 把棋盘的该位置标记为已经走的步数
        chessbord[rom][column] = step;
        // 获取该位置的下一个可以走的位置集合
        List<Location> nextLocation = nextLocation(new Location(column, rom));
        //如果该集合不为null,则进行递归（深度优先）
        while (!nextLocation.isEmpty()) {
            Location location = nextLocation.remove(0);
            // 如果该位置没被访问过，这进行递归
            if (!visited[location.y * chessbord[0].length + location.x]) {
                traversalChessboard(location.y, location.x, step + 1);
            }
        }

        // 代码走到走到这，说明已经没有位置可以走了
        if (step < visited.length && !finished ) {
            // 如果整个棋盘还没有走完,就把该位置设置为没有走过（进行回溯，返回到上一步）
            chessbord[rom][column] = 0;
            visited[rom * chessbord[0].length + column] = false;
        } else {
            finished = true;
        }
    }

    /**
     * 内部类，表示棋盘的位置
     */
    private static class Location{
        // 表示列
        int x;
        // 表示行
        int y;
        public Location(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    /**
     * 表示当前这个位置下一步可以走的位置
     * @param location 当前的位置
     * @return 返回位置集合
     */
    private List<Location> nextLocation(Location location) {
        List<Location> locationList = new ArrayList<>();
        // 当前位置的行
        int y = location.y;
        // 当前位置的列
        int x =  location.x;

        if (x - 2 >= 0 && y - 1 >= 0) {
            Location location1 = new Location(x - 2, y - 1);
            locationList.add(location1);
        }
        if (x - 1 >= 0 && y - 2 >= 0) {
            Location location1 = new Location(x - 1, y - 2);
            locationList.add(location1);
        }
        if (x + 1 < chessbord[0].length && y - 2 >= 0) {
            Location location1 = new Location(x + 1, y - 2);
            locationList.add(location1);
        }
        if (x + 2 < chessbord[0].length && y - 1 >= 0) {
            Location location1 = new Location(x + 2, y - 1);
            locationList.add(location1);
        }
        if (x + 2 < chessbord[0].length && y + 1 < chessbord.length) {
            Location location1 = new Location(x + 2, y + 1);
            locationList.add(location1);
        }
        if (x + 1 < chessbord[0].length && y + 2 < chessbord.length) {
            Location location1 = new Location(x + 1, y + 2);
            locationList.add(location1);
        }
        if (x - 1 >= 0 && y + 2 < chessbord.length) {
            Location location1 = new Location(x - 1, y + 2);
            locationList.add(location1);
        }
        if (x - 2 >= 0 && y + 1 < chessbord.length) {
            Location location1 = new Location(x - 2, y + 1);
            locationList.add(location1);
        }
        return locationList;
    }
}

测试

public class MyTest {
    public static void main(String[] args) {
        int[][] chessboard = new int[8][8];

        HorseChessboard horseChessboard = new HorseChessboard(chessboard);
        long start = System.currentTimeMillis();
        horseChessboard.traversalChessboard(0,0, 1);
        long end = System.currentTimeMillis();
        System.out.println("花费时间：" + (end - start) + "毫秒");
        horseChessboard.show();
    }
}

测试结果

花费时间：23567毫秒
走的步数：0
[1, 8, 11, 16, 3, 18, 13, 64]
[10, 27, 2, 7, 12, 15, 4, 19]
[53, 24, 9, 28, 17, 6, 63, 14]
[26, 39, 52, 23, 62, 29, 20, 5]
[43, 54, 25, 38, 51, 22, 33, 30]
[40, 57, 42, 61, 32, 35, 48, 21]
[55, 44, 59, 50, 37, 46, 31, 34]
[58, 41, 56, 45, 60, 49, 36, 47]

我们看运行结果一共花费了23秒，速度还是比较慢的
我们分析下速度为什么会慢，有没有优化的方法：

  1. 速度比较慢是因为每一次走下一步的时候有许多选择，最多的时候有8种走法，下一步的下一步也是有很多种走法。
  2. 如果我们的下一步的下一步是选择走法最多的那一种，那么方法递归的次数就会增加很多。
  3. 所以我们如果在下一步走的时候选择下一步的下一步走法比较少的那种走法，方法递归的次数就减少，从而达到优化的效果
贪心算法优化

从上面的分析结果可以得出，我们如果没走下一步的时候，选择下一步的下一步走法比较的那个一步，那就就会减少递归次数。代码示例

/**
 * 马踏棋盘算法
 */
public class HorseChessboard {
    // 棋盘
    private int[][] chessbord;
    // 标记对应的位置是否被访问过，总的大小 = 棋盘的 X*Y, 8*8 = 64
    private boolean[] visited;
    // 记录走的部数
    private int step;
    //使用一个属性，标记是否棋盘的所有位置都被访问
    private static boolean finished; // 如果为true,表示成功

    public HorseChessboard(int[][] chessbord) {
        this.chessbord = chessbord;
        visited = new boolean[chessbord.length * chessbord[0].length];
    }

    public void show() {
        System.out.println("走的步数：" + step);
        for (int[] ints : chessbord) {
            System.out.println(Arrays.toString(ints));
        }
    }

    //根据当前这个一步的所有的下一步的选择位置，进行非递减排序, 减少回溯的次数
    private void sort(List<Location> locations) {
        locations.sort(new Comparator<Location>() {
            @Override
            public int compare(Location o1, Location o2) {
                //获取到o1的下一步的所有位置个数
                int count1 = nextLocation(o1).size();
                //获取到o2的下一步的所有位置个数
                int count2 = nextLocation(o2).size();
                if(count1 < count2) {
                    return -1;
                } else if (count1 == count2) {
                    return 0;
                } else {
                    return 1;
                }
            }
        });
    }

    /**
     * 完成骑士周游问题
     * @param rom 骑士开始的走 第几行
     * @param column 骑士开始的走 第几列
     */
    public void traversalChessboard(int rom, int column, int step) {
        // 记录该位置被访问
        visited[rom * chessbord[0].length + column] = true;
        // 把棋盘的该位置标记为已经走的步数
        chessbord[rom][column] = step;
        // 获取该位置的下一个可以走的位置集合
        List<Location> nextLocation = nextLocation(new Location(column, rom));
        // 贪心算法优化，排序，按照下一次走法比较小的递增
        sort(nextLocation);
        //如果该集合不为null,则进行递归（深度优先）
        while (!nextLocation.isEmpty()) {
            Location location = nextLocation.remove(0);
            // 如果该位置没被访问过，这进行递归
            if (!visited[location.y * chessbord[0].length + location.x]) {
                traversalChessboard(location.y, location.x, step + 1);
            }
        }

        // 代码走到走到这，说明已经没有位置可以走了
        if (step < visited.length && !finished ) {
            // 如果整个棋盘还没有走完,就把该位置设置为没有走过（进行回溯，返回到上一步）
            chessbord[rom][column] = 0;
            visited[rom * chessbord[0].length + column] = false;
        } else {
            finished = true;
        }
    }

    /**
     * 内部类，表示棋盘的位置
     */
    private static class Location{
        // 表示列
        int x;
        // 表示行
        int y;
        public Location(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    /**
     * 表示当前这个位置下一步可以走的位置
     * @param location 当前的位置
     * @return 返回位置集合
     */
    private List<Location> nextLocation(Location location) {
        List<Location> locationList = new ArrayList<>();
        // 当前位置的行
        int y = location.y;
        // 当前位置的列
        int x =  location.x;

        if (x - 2 >= 0 && y - 1 >= 0) {
            Location location1 = new Location(x - 2, y - 1);
            locationList.add(location1);
        }
        if (x - 1 >= 0 && y - 2 >= 0) {
            Location location1 = new Location(x - 1, y - 2);
            locationList.add(location1);
        }
        if (x + 1 < chessbord[0].length && y - 2 >= 0) {
            Location location1 = new Location(x + 1, y - 2);
            locationList.add(location1);
        }
        if (x + 2 < chessbord[0].length && y - 1 >= 0) {
            Location location1 = new Location(x + 2, y - 1);
            locationList.add(location1);
        }
        if (x + 2 < chessbord[0].length && y + 1 < chessbord.length) {
            Location location1 = new Location(x + 2, y + 1);
            locationList.add(location1);
        }
        if (x + 1 < chessbord[0].length && y + 2 < chessbord.length) {
            Location location1 = new Location(x + 1, y + 2);
            locationList.add(location1);
        }
        if (x - 1 >= 0 && y + 2 < chessbord.length) {
            Location location1 = new Location(x - 1, y + 2);
            locationList.add(location1);
        }
        if (x - 2 >= 0 && y + 1 < chessbord.length) {
            Location location1 = new Location(x - 2, y + 1);
            locationList.add(location1);
        }
        return locationList;
    }
}

运行结果：`

花费时间：33毫秒
走的步数：0
[1, 16, 37, 32, 3, 18, 47, 22]
[38, 31, 2, 17, 48, 21, 4, 19]
[15, 36, 49, 54, 33, 64, 23, 46]
[30, 39, 60, 35, 50, 53, 20, 5]
[61, 14, 55, 52, 63, 34, 45, 24]
[40, 29, 62, 59, 56, 51, 6, 9]
[13, 58, 27, 42, 11, 8, 25, 44]
[28, 41, 12, 57, 26, 43, 10, 7]

从结果可以看出经过贪心算法优化，花费的时间才33毫秒，而没有优化前花了了23秒，可以看出经过算法优化的魅力，大大提高了程序的效率。

贪心算法优化的核心是每次对下一次可以的步数进行从小到大排序
核心方法如下:

  //根据当前这个一步的所有的下一步的选择位置，进行非递减排序, 减少回溯的次数
    private void sort(List<Location> locations) {
        locations.sort(new Comparator<Location>() {
            @Override
            public int compare(Location o1, Location o2) {
                //获取到o1的下一步的所有位置个数
                int count1 = nextLocation(o1).size();
                //获取到o2的下一步的所有位置个数
                int count2 = nextLocation(o2).size();
                if(count1 < count2) {
                    return -1;
                } else if (count1 == count2) {
                    return 0;
                } else {
                    return 1;
                }
            }
        });
    }
魔舞清华-方
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
贪心算法 --- 马踏棋盘（C）
Jensen
11-30 4405
五大常用算法之一，好高大上的东西，决定了把这五大算法给搞了，第一个贪心算法，百度一下它的概念，贴过了来了： 贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。 贪婪算法是一种改进
二十五、程序员10大算法之马踏棋盘算法
陈大大的博客
10-26 379
一、马踏棋盘算法介绍 二、代码实现 import java.awt.Point; import java.util.ArrayList; import java.util.Comparator; public class HorseChessboard { private static int X; // 棋盘的列数 private static int Y; // 棋盘的行数 //创建一个数组，标记棋盘的各个位置是否被访问过 private static boolean visited[
利用贪心算法优化马踏棋盘算法
weixin_45829957的博客
08-16 1174
马踏棋盘算法介绍和游戏演示 1)马踏棋盘算法也被称为骑士周游问题 2)将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格 3)游戏演示: http://www.4399.com/flash/146267_2.htm 马踏棋盘游戏代码实现 1)马踏棋盘问题(骑士周游问题)实际上是图的深度优先搜索(DFS)的应用。 ● 2)如果使用回溯（就是深度优先搜索）来解决，假如马儿踏了...
马踏棋盘算法
amateur_RD的博客
10-25 833
马踏棋盘算法代码为.c文件# include <stdio.h> # include <stdlib.h> # include <math.h> # define ROWS 8 # define COLS 8 int cheesboard [ROWS] [COLS]; const int moveX [8] = {-2,-1,1,2,2,1,-1,-2}; const int moveY [8] =
马踏棋盘的贪心算法实现
10-24
在马踏棋盘问题中，贪心算法可能的具体实现步骤如下： 1. **初始化**：设定一个空的访问数组，用来标记棋盘上的每个格子是否已被马访问过。同时，定义起点，通常为棋盘的左上角，并标记为已访问。 2. **贪心策略**...
马踏棋盘问题（C语言）——基于贪心算法优化的深度优先搜索
03-30
马踏棋盘问题（骑士巡游问题）的基于贪心算法优化深度搜索可视化实现 用c语言实现的，在命令台中会动态的显示棋盘上棋子路径
马踏棋盘贪心算法.doc
05-08
马踏棋盘贪心算法 马踏棋盘问题是指在一个8x8的棋盘上，从任意指定...使用贪心算法可以大大提高搜索效率，使得马踏棋盘问题的解决速度明显提高。同时，这种算法也可以应用于其他搜索问题中，提高搜索效率和解决速度。
马踏棋盘C语言贪心算法.c
04-11
马踏棋盘C语言贪心算法 将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格
基于python 的贪心算法解决8x8马踏棋盘问题并可视化
最新发布
07-11
【作品名称】：基于贪心算法解决8x8马踏棋盘问题并可视化 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 基于贪心...
算法-马踏棋盘算法
Shawn Jeon`s blog
11-14 621
马踏棋盘算法概述 概述 马踏棋盘算法也被称为骑士周游问题, 规则是将马随机放在国际象棋的6x6棋盘(board[05][05])的某个方格中, 马儿走棋规则(马走日字)进行移动, 且每个方格只进入一次, 走遍所有方格 代码思路 深度优先搜索(Depth First Search): 每当走到尽头未走完所有方格, 便会回退, 也就是会发生大量的回溯 使用贪心算法(Greedy algorithm), 优化深度优先搜索时产生的回溯 代码实现 public class HorseChessbo
算法：马踏棋盘算法
lsh199196的专栏
02-14 1473
在图中寻找哈密尔顿路径。 定义：将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格。 算法：如图： 马踏棋盘的一个点：对于n*n的棋盘上，当n》=5且为偶数的情况下，以任意点都有解。 一些相关的知识： 1、回溯法 思想很简单，一条路走到黑，碰壁了再回来一条路走到黑，一
算法之马踏棋盘
tony820418的专栏
11-27 283
马踏棋盘算法，使用递归与回朔算法，完成时效率极低，当棋盘8*8时，已经很慢了。 修改一下算法， 当进行某一格的下一步n个位置选择时(ABCDEFG)，把这n个位置排个序，按照下一步可走的位置的个数从小到大排序，遍历时按这个顺序进行，效率提交非常高，16*16的一秒就可以出结果。 以下代码随便写的，可以跑通，有很多优化的地方。 import java.util.*; import java....
马踏棋盘算法（骑士周游问题）
Ronz 的博客
02-08 5223
一、问题概述 马踏棋盘算法也被称为骑士周游问题。问题内容是： 将马随机放在国际象棋的 8× 8 棋盘的某个方格中， 马按走棋规则（马走日字）进行移动。要求每个方格只能走一次， 走遍棋盘上全部 64 个方格，求可行的路径。 二、思路分析 马踏棋盘问题实际上是图的深度优先搜索（DFS）的应用。 该问题的解决思想为： 假设以 V 为起点，首先找出在指定规则下 V 点下一步可能的落点。 在下一步的可能的落点中选择一个点（假设是 U 点），然后走到 U 点。 再以 U 点为起点，找出指定规则下 U 点下一步可能的
算法其实很简单—马踏棋盘算法（骑士周游）
我愿随风而行 的博客
06-27 2714
目录 1.马踏棋盘算法介绍和游戏演示 2.马踏棋盘游戏代码实现 3.骑士周游问题的解决步骤和思路 4.代码优化 5.代码实现 1.马踏棋盘算法介绍和游戏演示 1)马踏棋盘算法也被称为骑士周游问题 2)将马随机放在国际象棋的8X8棋盘Board[0~ 7][0~7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格 3) 游戏演示: http://www.4399.com/flash/146267_2.htm 2.马踏棋盘游戏代码实.
算法设计技巧：马踏棋盘与回溯法解析
贪心算法的特点是在每一步选择局部最优解，希望这些局部最优解组合起来能导致全局最优解。而四色问题和n后问题则分别对应了图的着色问题和动态规划问题。四色问题指出任何平面图都可以用四种颜色进行着色，使得没有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值