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(int* x,int* y,int where){
 
    switch(where){
        case 0:
            if(*x+1<X&&*y-2>=0&&chess[*y-2][*x+1]==0){
                *x+=1;
                *y-=2;
                return 1;
            }
            break;
        case 1:
            if(*x+2<X&&*y-1>=0&&chess[*y-1][*x+2]==0){
                *x+=2;
                *y-=1;
                return 1;
            }
            break;
        case 2:
            if(*x+2<X&&*y+1<Y&&chess[*y+1][*x+2]==0){
                *x+=2;
                *y+=1;
                return 1;
            }
            break;
        case 3:
            if(*x+1<X&&*y+2<Y&&chess[*y+2][*x+1]==0){
                *x+=1;
                *y+=2;
                return 1;
            }
            break;
        case 4:
            if(*x-1>=0&&*y+2<Y&&chess[*y+2][*x-1]==0){
                *x-=1;
                *y+=2;
                return 1;
            }
            break;
        case 5:
            if(*x-2>=0&&*y+1<Y&&chess[*y+1][*x-2]==0){
                *x-=2;
                *y+=1;
                return 1;
            }
            break;
        case 6:
            if(*x-2>=0&&*y-1>=0&&chess[*y-1][*x-2]==0){
                *x-=2;
                *y-=1;
                return 1;
            }
            break;
        case 7:
            if(*x-1>=0&&*y-2>=0&&chess[*y-2][*x-1]==0){
                *x-=1;
                *y-=2;
                return 1;
            }
            break;
    }
    return 0;
}
 
int Explore(int x,int y){
    int x1=x;
    int y1=y;
    int flag;
    int where=0;
    
 
    counter++;
    chess[y][x]=counter;
    
 
    if(counter==X*Y){
        return 1;
    }
    
    
    
    flag=Next(&x1,&y1,where);
    while(flag==0&&where<7){
        where++;
        flag=Next(&x1,&y1,where);
    }
    
    
    while(flag){
        if(Explore(x1,y1)==1){
            return 1;
        }
        else{
            x1=x;
            y1=y;
            where++;
            flag=Next(&x1,&y1,where);
            while(flag==0&&where<7){
                where++;
                flag=Next(&x1,&y1,where);
            }
        }
    }
    if(flag==0){
        chess[y][x]=0;
        counter--;
    }
    return 0;
}
 
void ShowResult(){
    
    for(int i=0;i<Y;i++){
        for(int j=0;j<X;j++){
            cout.width(4);
            cout<<chess[i][j]<<' ';
        }
        cout<<endl;
    }
    cout<<endl;
}
 
int main(){
    int start=clock();
    int result=Explore(2,1);
    int end=clock();
    if(result){
        ShowResult();        
    }
    else{
        cout<<"have no path!"<<endl; 
    }
 
    cout<<"spend time:"<<(end-start)/CLOCKS_PER_SEC<<" s"<<endl;
    return 0;
}

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

(0)

相关推荐

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

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

  • 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++贪心算法实现马踏棋盘

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

  • 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

  • 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;        

随机推荐