C++骑士游历问题(马踏棋盘)解析

骑士游历问题:在国际棋盘上使一个骑士遍历所有的格子一遍且仅一遍,对于任意给定的顶点,输出一条符合上述要求的路径

解题思路:

这是一道经典的遍历问题(DFS),由于题目要求遍历全部,那么肯定要做标记,因此立马想到DFS深度优先算法。具体思路如下:

①了解国际象棋以及国际象棋骑士的走法

国际象棋和中国象棋,大同小异,毕竟中国象棋是老祖先。国际象棋棋子放在格子中,中国象棋放在点上,且国际象棋有64个格子。国际象棋的骑士和中国象棋的马功能相当,都可以走八个方位。走法是走“日”字,或英文字母大写的“L”形:即先向左(或右)走1格,再向上(或下)走2格;或先向左(或右)走2格,再向上(或下)走1格。与中国象棋的馬不同,国际象棋的马可以跳过路上的其他棋子,不受拐脚的限制。
解题需要我们可以把格子抽象成一个点,那么国际象棋的骑士走法就是一个日字。

②设置标记

初始化数组,让每个元素初始化为0,并且初始化一个记录骑士遍历次数的cal也为0

int cal = 0; //统计走的顺序
//初始化为0
int chress[8][8] =           
{
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0
};

③判断是否超界和是否被访问

bool ifOut(int x, int y)  //判断是否出界
{
    if (x >= 0 && x <= 7 && y >= 0 && y <= 7)
        return false;
    else
        return true;
}
bool ifVisited(int x, int y) //判断是否被访问
{
    if (chress[x][y] != 0)
        return true;
    else
        return false;
}

④递归主体

void dfs(int x,int y)
{    
    if (cal == 64) //如果遍历完则退出棋盘一共64个位置
        return;
    if (!ifVisited(x, y) && !ifOut(x, y)) //如果没有被访问且没有出界 则访问
    {
        cal++;   
        chress[x][y] = cal; //做标记
        dfs(x + 2, y + 1);    //骑士走法有八个方位,故八个 方位都遍历
        dfs(x - 2, y - 1);   //八个递归的顺序可以改,顺序不一样,结果不一样
        dfs(x + 2, y - 1);    
        dfs(x - 2, y + 1);    
        dfs(x - 1, y - 2);  
        dfs(x + 1, y - 2);    
        dfs(x + 1, y + 2);    
        dfs(x - 1, y + 2);  
        return;
    }
    else  //else其中包括已经被访问了,和没有被访问且在界外的
        return;
}

⑤总代码如下(编译器vs2013)

#include"stdafx.h"
#include<iostream>
#include<iomanip>
using namespace std;
int cal = 0; //统计走的顺序
//棋盘初始化为0做标记
int chress[8][8] =           
{
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0
};

bool ifOut(int x, int y)  //判断是否出界
{
    if (x >= 0 && x <= 7 && y >= 0 && y <= 7)
        return false;
    else
        return true;
}
bool ifVisited(int x, int y) //判断是否已经被访问
{
    if (chress[x][y] != 0)
        return true;
    else
        return false;
}
void dfs(int x,int y)
{    
    if (cal == 64) //如果遍历完则退出棋盘一共64个位置
        return;
    if (!ifVisited(x, y) && !ifOut(x, y)) //如果没有被访问且没有出界 则访问
    {
        cal++;   
        chress[x][y] = cal; //做标记
        dfs(x + 2, y + 1);    //骑士走法有八个方位,故八个 方位都遍历
        dfs(x - 2, y - 1);  //八个递归的顺序可以改,顺序不一样,结果不一样 
        dfs(x + 2, y - 1);    
        dfs(x - 2, y + 1);    
        dfs(x - 1, y - 2);  
        dfs(x + 1, y - 2);    
        dfs(x + 1, y + 2);    
        dfs(x - 1, y + 2);  
        return;
    }
    else  //出界了则退出return
        return;

}
int main()
{    
    int x, y;
    cout << "请输入骑士初始的位置:";
    while (1)
    {
        cin >> x >> y;    //输入坐标
        if (x > 7 || x<0 || y> 7 || y < 0)
            cout << "初始位置输入错误请重新输入" << endl;
        else
            break;
    }
    dfs(x,y);
    for (int i = 0; i < 8; i++)  //输出打印测试
    {
        for (int j = 0; j < 8; j++)
            cout << setw(2)<<chress[i][j]<<"  ";
        cout << endl;
    }
    return 0;
}

⑥测试截图:

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • C++实现马踏棋盘(骑士周游)

    马踏棋盘,用1枚马走遍棋盘.我用一个二维数组记录模拟的整个路径,x为列,y为行,以顺时针的方式寻找下一格,算法比较简单,就通过递归和循环回溯即可,就是如果是8*8的数组,最坏可能执行8^(x*y)次,耗时长到怀疑人生. #include<iostream> #define X 5 #define Y 5   void ShowResult(); using namespace std;   int chess[Y][X]={     0 }; int counter=0;   int Next

  • C++贪心算法实现马踏棋盘

    本文实例为大家分享了C++贪心算法实现马踏棋盘的具体代码,供大家参考,具体内容如下 算法实现流程: 步骤1:初始化马的位置(结构体horse {x, y}) 步骤2:确定马从当前点出发,可跳跃的附近8个点,以结构体Jump数组给出,但需判断当前给出的附近8个点是否曾经访问过,或者是否这8个点超出棋盘尺寸. 步骤3:跟据步骤2确定跳跃的点,分别计算可跳跃点的下下一步,可跳跃点的个数.并选出下下步可跳跃点数最少的点作为马下一步跳跃的点.(举例说明:马当前所在点坐标(4,4),下一步可跳跃点有(5,2

  • C++基于栈的深搜算法实现马踏棋盘

    马踏棋盘(基于栈的深搜算法实现) 简单来说,从任意指定方格出发,为马寻找一条走遍棋盘每一格并且只经过一次的一条路径,这就是马踏棋盘的简单描述. 话不多说,代码如下,要是有什么不懂的地方,欢迎讨论~ #include <stdio.h> #include <stdlib.h> #define M 8 //行 #define N 8 //列   typedef struct snode    //坐标 {     int flag;     int x;     int y; }sta

  • C/C++实现马踏棋盘算法

    本文实例为大家分享了C/C++实现马踏棋盘的具体代码,供大家参考,具体内容如下 问题描述:将马随机放在国际象棋的8×8棋盘Board[0-7][0-7]的某个方格中,马按走棋规则进行移动.要求每个方格只进入一次,走遍棋盘上全部64个方格. 问题求解算法简述: 1.深度优先遍历+回溯法 2.贪心算法+深度优先遍历+回溯法 解法1描述: 1.使用一个二维数组Step[8][8]= {-1}来表示棋盘,起跳位置做为当前位置Step[i][j],设置NumOfSteps = 0: 2.设置当前位置Ste

  • C++骑士游历问题(马踏棋盘)解析

    骑士游历问题:在国际棋盘上使一个骑士遍历所有的格子一遍且仅一遍,对于任意给定的顶点,输出一条符合上述要求的路径 解题思路: 这是一道经典的遍历问题(DFS),由于题目要求遍历全部,那么肯定要做标记,因此立马想到DFS深度优先算法.具体思路如下: ①了解国际象棋以及国际象棋骑士的走法 国际象棋和中国象棋,大同小异,毕竟中国象棋是老祖先.国际象棋棋子放在格子中,中国象棋放在点上,且国际象棋有64个格子.国际象棋的骑士和中国象棋的马功能相当,都可以走八个方位.走法是走“日”字,或英文字母大写的“L”形

  • java实现马踏棋盘算法(骑士周游问题)

    骑士周游问题 在8x8的国际棋盘上,按照马走日的规则,验证是否能够走遍棋盘. 解题思路 1.创建棋盘 chessBoard,是一个二维数组.2.将当前位置设置为已经访问,然后根据当前位置,计算马儿还能走哪些位置,并放入到一个集合中(ArrayList),最多有8个位置,每走一步,就使用step+1.3.遍历ArrayList中存放的所有位置,看看哪个可以走通,如果走通,就继续,走不通,就回溯.4.判断马儿是否完成了任务,使用step和应该走的步数比较,如果没有达到数量,则表示没有完成任务,将整个

  • java数据结构和算法之马踏棋盘算法

    本文实例为大家分享了java实现算法之马踏棋盘的具体代码,供大家参考,具体内容如下 一.马踏棋盘算法介绍 马踏棋盘算法也被称为骑士周游问题将马随机放在国际象棋的8×8棋盘Board[0-7][0-7]的某个方格中,马按走棋规则(马走日字)进行移动.要求每个方格只进入一次,走遍棋盘上全部64个方格 二.骑士周游问题的思路分析 1.创建棋盘 chessBoard , 是一个二维数组2.将当前位置设置为已经访问,然后根据当前位置,计算马儿还能走哪些位置,并放入到一个集合中(ArrayList), 最多

  • java实现马踏棋盘的算法

    本文实例为大家分享了java实现马踏棋盘的具体代码,供大家参考,具体内容如下 马踏棋盘算法介绍 8X8棋盘,马走日字,要求每个方格只进入一次,走遍棋盘上全部64个方格. 代码: public class HorseChessBoard {     private static int X;//棋盘的列数     private static int Y;//棋盘的行数     //创建一个数组,标记棋盘的各个位置是否被访问过     private static boolean visited[

  • java学习笔记之马踏棋盘算法

    马踏棋盘或骑士周游问题 1.马踏棋盘算法也被称为骑士周游问题2.将马随机放在国际象棋的 8×8 棋盘 Board[0-7][0-7]的某个方格中,马按走棋规则(马走日字)进行移动.要求每个方格只进入一次,走遍棋盘上全部 64 个方格 思路 会使用到深度优先思想和类似迷宫问题的寻路策略问题,和八皇后问题也有相似. 1.用一个二维数组建立整张棋盘.用另外一个二维数组保存棋盘的每一个位置是否走过2.马在棋盘上有一个初始位置,将这个位置设为已走过,并将步数设为1.3.获得在这个位置上,马下一步能走的位置

  • java数据结构与算法之马踏棋盘

    本文实例为大家分享了java数据结构与算法之马踏棋盘的具体代码,供大家参考,具体内容如下 马踏棋盘算法也被称为骑士周游问题 将马随机放在过期象棋的8x8棋盘的某个方格中,马按走棋规则进行移动,要求每个方格只进入一次,走遍棋盘上全部64个方格 骑士周游问题结局步骤和思路 1.创建棋盘chessBoard,是一个二维数组2.将当前位置设置为已个访问,然后根据当前位置,计算马儿还能走那些位置,并放到一个集合中(ArrayList),最多8个位置3.变量ArrayList存放的所有位置,看看哪个可以走通

  • Python基于回溯法子集树模板解决马踏棋盘问题示例

    本文实例讲述了Python基于回溯法子集树模板解决马踏棋盘问题.分享给大家供大家参考,具体如下: 问题 将马放到国际象棋的8*8棋盘board上的某个方格中,马按走棋规则进行移动,走遍棋盘上的64个方格,要求每个方格进入且只进入一次,找出一种可行的方案. 分析 说明:这个图是5*5的棋盘. 类似于迷宫问题,只不过此问题的解长度固定为64 每到一格,就有[(-2,1),(-1,2),(1,2),(2,1),(2,-1),(1,-2),(-1,-2),(-2,-1)]顺时针8个方向可以选择. 走到一

  • java实现马踏棋盘的完整版

    本文实例为大家分享了java实现马踏棋盘的具体代码,供大家参考,具体内容如下 马踏棋盘很好实现,但有时运行起来特别慢,还可能出不来结果,在这里要用到贪心算法来优化,即找出最难走的路径,也就是下下步可下棋的位置最少. 下面给出该算法完整代码: /*      * 马踏棋盘问题:(贪婪法求解)      * 棋盘有64个位置,"日"字走法,刚好走满整个棋盘      */     //下一个走法的方向类     class Direction{         int x;        

  • Java实现马踏棋盘算法

    本文实例为大家分享了Java实现马踏棋盘的具体代码,供大家参考,具体内容如下 马在某个点最多可能有8种走法,用递归和回溯实现. 注:代码中,查找下一个可走坐标是从右下第一个开始的,也就是图中的4.可以通过修改a,b...h的值来改变顺序. 代码: /**  * 马踏棋盘算法   * 递归和回溯  *  */ public class HorseStep {          public static int X = 8;     public static int Y = 8;        

随机推荐