马踏棋盘（从低效到高效）

最新推荐文章于 2024-04-13 16:14:34 发布
最新推荐文章于 2024-04-13 16:14:34 发布
阅读量1.4k 收藏 31
点赞数 8
分类专栏： 算法 文章标签： 马踏棋盘问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43646576/article/details/102555670
版权

题目描述

将棋子“马”随机的放在国际象棋棋盘Board[8][8]的某个方格中，“马”按走棋规则进行移动，要求每个方格只进入一次，走遍棋盘上所有的64个方格。

题目要求

编写非递归程序，求出“马”的行走路线，并按求出的行走路线将数字1-64依次填入一个8x8的方阵并输出。

分析 x 1

一看题目说是8x8棋盘，要求走遍棋盘，首先想到的便是直接深搜即可，但是后面说到要求非递归程序，这也简单，自己把递归的那一部分
改为用栈来实现即可（马走棋盘肯定会遇到走不下去的情况，所以需要储存之前已经走过的点，而“悔棋”肯定是从当前这一步往之前返
回，所以是一个后进先出的结构——栈）。
定义
typedef struct _horse
{
    int x;  //横坐标
    int y;  //纵坐标
    int s;  //下一步的方向
}HORSE;
int chessboard[8][8];   //棋盘
int Next[8][2] = {{2,1}, {1,2}, {-1,2}, {-2,1}, {-2,-1}, {-1,-2}, {1,-2}, {2,-1}};  //方向
int cnt = 1;            //计数器
stack<HORSE> horse;
执行函数
bool judge(int a, int b)
{
    if(a < 0 || a > 7 || b < 0 || b > 7)    //边界
        return false;
    return true;
}

void Horse(int x, int y)
{
    HORSE temp;
    int a,b;	//记录当前马位置附近的坐标
    int i = 0;
    chessboard[x][y] = cnt;	//标记当前起始位置已被访问 
    temp.x = x;	//记录当前马的位置
    temp.y = y;
    while(cnt < 64)
    {
        for(; i < 8; i++)
        {
            a = temp.x + Next[i][0];
            b = temp.y + Next[i][1];
            if(judge(a,b) && chessboard[a][b] == 0)     //判断
            {
                break;
            }
        }
        if(i < 8)	//能够访问当前马位置附近的日点
        {
            chessboard[a][b] = ++cnt;
            temp.s = i;
            horse.push(temp);
            memset(&temp, 0, sizeof(HORSE));
            temp.x = a;
            temp.y = b;
            i = 0;
        }
        else	//回溯
        {
            --cnt;
            chessboard[temp.x][temp.y] = 0;
            HORSE tt = horse.top();
            horse.pop();
            temp.x = tt.x;
            temp.y = tt.y;
            i = tt.s;
            ++i;	//继续搜索从当前马位置访问的点的下一个点继续访问
        }
    }
}

完成后测试了一下，只有（0，0）可以跑出来，可见这种暴力的方式效率实在是太低…

分析 x 2

上面的暴力试探方式效率实在太低了，所以我们要优化一下代码。
把书继续往后翻，有提到将马的初始步入栈，计算其8个方向的权值，将其按升序排列，马从最小权值的点开始走，
无路可走时回溯（权值就是一个点下一步能走的点的总数）。
这是一种贪心的思想，那么既然是贪心，我们可不可以再贪心一些，每一步直接走权值最小的点，不再回溯，看能不能走完。
执行函数
void Horse(int x, int y)
{
    HORSE temp;
    int a,b;    //记录当前马位置附近的坐标
    chessboard[x][y] = cnt; //标记当前起始位置已被访问 
    temp.x = x; //记录当前马的位置
    temp.y = y;
    while(cnt < 64)
    {
        int h_min = 8;      //权值最小的点
        int tx,ty,ti;       //记录权值最小的点的信息
        for(int i = 0; i < 8; i++)
        {
            a = temp.x + Next[i][0];
            b = temp.y + Next[i][1];
            if(judge(a,b) && chessboard[a][b] == 0)     //判断
            {
                int step = steps(a,b);   //计算权值
                if(step < h_min)         //更新权值最小的点
                {
                    h_min = step;    
                    tx = a;
                    ty = b;
                    ti = i;
                }            
            }
        }
        //直接走权值最小的点
        chessboard[tx][ty] = ++cnt;
        temp.s = ti;
        //temp.step = h_min;
        horse.push(temp);
        memset(&temp, 0, sizeof(HORSE));
        temp.x = tx;
        temp.y = ty;
    }
}

这次测试了一下，效率大大的提高了，但是我们是“最”贪心的方法，所以我们要测试一下，看能不能从任意点出发都能走完棋盘。
经过测试有一个点不能走完棋盘，就是（2，4），也就是三行五列的点。

分析 x 3

好吧，既然只有一个点不能按照我们最贪心的方式走完，那么我们就只对这一个点特殊处理一下。
处理方式即就是分析2时所说的按权值大小排序，从最小的开始走。

最终版本

#include <iostream>
#include <stack>
#include <cstring>
#include <algorithm>

using namespace std;

/* 马踏棋盘 */

typedef struct _horse
{
    int x;  //横坐标
    int y;  //纵坐标
    int s;  //下一步的方向
    int step;   //下一步的权值
    int flag;  //特殊点用
}HORSE;

int chessboard[8][8];   //棋盘
int Next[8][2] = {{2,1}, {1,2}, {-1,2}, {-2,1}, {-2,-1}, {-1,-2}, {1,-2}, {2,-1}};  //方向
int cnt = 1;            //计数器
stack<HORSE> horse;

//判别
bool judge(int a, int b)
{
    if(a < 0 || a > 7 || b < 0 || b > 7)    //边界
        return false;
    return true;
}

//从小到大排序
bool cmp(HORSE& a, HORSE& b)
{
    return a.step < b.step;
}

//计算权值
int steps(int a, int b)
{
    int sum = 0;
    for(int i = 0; i < 8; i++)
    {
        int x = a + Next[i][0];
        int y = b + Next[i][1];
        if(judge(x,y) && chessboard[x][y] == 0)
            ++sum;
    }
    return sum;
}

//执行过程
void Horse(int x, int y)
{
    HORSE temp;
    int a,b;    //记录当前马位置附近的坐标
    chessboard[x][y] = cnt; //标记当前起始位置已被访问 
    temp.x = x; //记录当前马的位置
    temp.y = y;
    while(cnt < 64)
    {
        int h_min = 8;      //权值最小的点
        int tx,ty,ti;       //记录权值最小的点的信息
        for(int i = 0; i < 8; i++)
        {
            a = temp.x + Next[i][0];
            b = temp.y + Next[i][1];
            if(judge(a,b) && chessboard[a][b] == 0)     //判断
            {
                int step = steps(a,b);   //计算权值
                if(step < h_min)         //更新权值最小的点
                {
                    h_min = step;    
                    tx = a;
                    ty = b;
                    ti = i;
                }            
            }
        }
        //直接走权值最小的点
        chessboard[tx][ty] = ++cnt;
        temp.s = ti;
        //temp.step = h_min;
        horse.push(temp);
        memset(&temp, 0, sizeof(HORSE));
        temp.x = tx;
        temp.y = ty;
    }
}

//特殊点执行过程（2，4）
void Horse_2(int x, int y)
{
    HORSE temp;
    HORSE horse_2[8];
    memset(horse_2, 0, sizeof(HORSE));
    int a,b;
    int flag = 0;   //记录该走那一个点了
    chessboard[x][y] = cnt;
    temp.x = x;
    temp.y = y;
    while(cnt < 64)
    {
        int k = 0;
        for(int i = 0; i < 8; i++)
        {
            a = temp.x + Next[i][0];
            b = temp.y + Next[i][1];
            if(judge(a,b) && chessboard[a][b] == 0)     //找出可走的点
            {
                int step = steps(a,b);
                horse_2[k].x = a;
                horse_2[k].y = b;
                horse_2[k].s = i;
                horse_2[k].step = step;
                ++k;
            }
        }
        sort(horse_2, horse_2 + k, cmp);    //按权值从小到大排序
        for(int i = 0; i < k; i++)
            horse_2[i].flag = i;    

        if(k > 0 && flag < k)   //有路可走
        {
            chessboard[horse_2[flag].x][horse_2[flag].y] = ++cnt;
            temp.s = horse_2[flag].s;
            temp.step = horse_2[flag].step;
            temp.flag = horse_2[flag].flag;
            horse.push(temp);
            memset(&temp, 0, sizeof(HORSE));
            temp.x = horse_2[flag].x;
            temp.y = horse_2[flag].y;
            flag = 0;
        }
        else    //回溯
        {
            --cnt;
            chessboard[temp.x][temp.y] = 0;
            HORSE tt = horse.top();
            horse.pop();
            temp.x = tt.x;
            temp.y = tt.y;
            flag = tt.flag;
            ++flag; //走下一个点
        }
    }
}

//输出
void print()
{
    for(int i = 0; i < 8; i++)
    {
        for(int j = 0; j < 8; j++)
            cout << chessboard[i][j] << ' ';
        cout << endl;
    }
}

int main()
{
    int x,y;
    cout << "从那个点开始: ";
    cin >> x >> y;
    if(x == 2 && y == 4)
        Horse_2(x,y);
    else
        Horse(x,y);
    print();
    return 0;
}

在这里插入图片描述

指关节
关注
  • 8
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
马踏棋盘问题
fakerth的博客
10-12 525
马踏棋盘也叫骑士周游问题，是指在一个8 * 8的国际棋盘上，从某一位置开始，每次走一个日字，将所有的位置都走一遍，要求每个方格只能进入一次，最终使得马走遍棋盘64个方格。
马踏棋盘C语言的完整算法
01-17
马踏棋盘C语言的完整算法 vs2013下编译运行通过
【数据结构】课程设计：马踏棋盘
Keikei419的博客
01-08 2260
My Data Structure curriculum assignment
算法——马踏棋盘算法（骑士周游问题）/图的深度优先遍历+贪心算法优化
最新发布
weixin_43713707的博客
04-13 597
马踏棋盘算法也叫骑士周游问题，其要求是：将马随机放在国际象棋的 8×8 棋盘 Board[0～7][0～7]的某个方格中，马按走棋规则()进行移动。要求，走遍棋盘上全部 64 个方格。
马踏棋盘 数据结构 C++简单暴力算法
qq_52788258的博客
07-21 1521
将马随机放在国际象棋的8×8棋盘Board[8][8]的某个方格中，马按走棋规则进行移动。要求每个方格只能进入一次，走遍棋盘上全部64个方格。编写非递归程序，求出马的行走路线，并按求出的行走路线，将数字1,2,3,…,64依次填入8×8的方阵，输出之。要求给出其中的100个解。...
算法-经典趣题-马踏棋盘（又称骑士周游）
joshua317的博客
09-14 1884
本文为joshua317原创文章,转载请注明：转载自joshua317博客算法-经典趣题-马踏棋盘（又称骑士周游） - joshua317的博客 一、问题 马踏棋盘问题,又称骑士漫步、，它是一个非常有趣的智力问题。马踏棋盘问题的大意如下： 国际象棋的棋盘有8行8列共64个单元格，无论将马放于棋盘的哪个单元格，都可让马踏遍棋盘的每个单元格。问马应该怎么走才可以踏遍棋盘的每个单元格？ 二、分析 我们来分析一下马踏棋盘问题。在国际象棋中，马只能走“日”字形，但是马位于不同的位置其可以走的方向有.
分治法解决马踏棋盘问题（马走日问题）
Isolarae's Coderonicles
07-08 5583
分治法解决马踏棋盘问题（马走日问题） 最终效果：https://chromezh.github.io/knights-tour-visualization/ 代码：https://github.com/chromezh/knights-tour-visualization 代码采用纯 C 语言编写，然后通过 Emscripten 将 C 语言编译为 JavaScript，放入网页中，使用...
马踏棋盘-数据结构 详细教程
A_Renaissance的博客
12-26 6530
国际象棋的棋盘为8×8的方格棋盘。现将“马”放在任意指定的方格中，按照“马”走棋的规则将“马”进行移动。要求每个方格只能进入一次，最终使得“马”走遍棋盘的64个方格。 编写一个C程序，实现马踏棋盘操作，要求用1〜64这64个数字标注马移动的路径，也就是按照求出的行走路线，将数字1，2，……64依次填入棋盘的方格中，并输出。
数据结构课程设计---马踏棋盘（C++）
qq_56725624的博客
06-20 6212
马踏棋盘：设计一个国际象棋的马踏遍棋盘的演示程序。将马随机放在国际象棋 8x8 棋盘 Board[8][8]的某个方格中，马按走棋规则进行移动。要求每个方格只进入一次，走遍棋盘上全部 64 个方格。编制递归或非递归程序，求出马的行走路线，并按求出的行走路线输出。结果中输出：在方阵中输出 1-64 个行走足迹。 ...
利用贪心算法优化马踏棋盘算法
weixin_45829957的博客
08-16 1134
马踏棋盘算法介绍和游戏演示 1)马踏棋盘算法也被称为骑士周游问题 2)将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格 3)游戏演示: http://www.4399.com/flash/146267_2.htm 马踏棋盘游戏代码实现 1)马踏棋盘问题(骑士周游问题)实际上是图的深度优先搜索(DFS)的应用。 ● 2)如果使用回溯（就是深度优先搜索）来解决，假如马儿踏了...
【数据结构与算法】马踏棋盘算法
qq_62200539的博客
08-24 279
马踏棋盘算法
马踏棋盘 栈 链表C++，C语言
12-30
马踏棋盘 栈 链表 按照老师的要求的。大家来下载吧· 但是计算算法比较冗余，计算不较慢。 #include #include "conio.h" using namespace std; #define edgetype int #define vextype int #define MAX 8 typedef struct node { int vextex;//序号 struct node *next; }edgenode; typedef struct { int vextex; int x,y; edgenode *link; }vexnode; const int px[8]={1,2,2,1,-1,-2,-2,-1}; const int py[8]={2,1,-1,-2,-2,-1,1,2}; const int L=8,H=8; vexnode ga[L*H]; //图 int visited[L*H]={0}; typedef struct /*顺序栈的结构体类型定义*/ { int stack[L*H]; int top; }seqstack; seqstack s; void setnull(seqstack *s) /*置空栈-由于c语言的数组下标是从0开始的，所以置 空栈操作时将栈顶指针放在下标为0之前，即-1处。*/ {s->top=-1;} int empty(seqstack *s) /*判断当前栈是否为空栈*/ { if(s->toptop>L*H-1) { printf("stack overflow!\n"); /*发生上溢*/ return 0; } else { s->stack[++s->top] = x; /*栈顶指针上移，数据元素入栈*/ return 1; } } int pop(seqstack *s) /*弹出当前栈s的栈顶元素*/ { if(s->toptop--; return(s->stack[s->top+1]); }/*由于return语句的特点，必须先使top减1，然后再执行return语句。而此时栈顶元素的表示应该为s->top+1.*/ } void init() { int n; for (int i=0;i<H;i++) { for (int j=0;j<L;j++) { n=L*i+j; ga[n].vextex=n; ga[n].x=j; ga[n].y=i; ga[n].link=NULL; } } printf("\n"); for (i=0;i<L*H;i++) //列出邻接链表 { edgenode *p; for (int k=0;k<MAX;k++) { int tx=ga[i].x+px[k]; int ty=ga[i].y+py[k]; if(tx<0||ty=L||ty>=H) continue; //出界了 else //采用前插法 { p=(edgenode*)malloc(sizeof(edgenode)); p->vextex=ty*L+tx; p->next=ga[i].link; ga[i].link=p; // printf("%d ",ga[i].link->vextex); } } } for (i=0;i<L*H;i++) { printf("%d ",ga[i].vextex); if (!((i+1)%L)) { printf("\n"); } } } void show() //打印邻接表 { int i; printf("\n"); for (i=0;i",ga[i].vextex); edgenode *p; p=(edgenode*)malloc(sizeof
国际象棋的马踏棋盘的演示程序
06-23
问题描述：设计一个国际象棋的马踏棋盘的演示程序 基本要求： 1.将马随机放在国际象棋的8×8棋盘的某个方格中，马按照走棋的规则进行移动。要求每个方格只进入一次，走遍棋盘的全部64个方格。编制非递归程序，求出马的行走路线，并按求出的行走路线，将1,2,…,64依次填入一个8×8的方阵，并输出。
数据结构马踏棋盘JAVA实验源码
06-18
在计算机科学领域，数据结构是编程的基础，它涉及到如何高效地存储和处理数据。本实验“马踏棋盘”是一个基于Java语言的数据结构应用实例，旨在通过动态演示帮助学习者理解数据结构的核心概念。在这个实验中，我们将...
Python基于回溯法子集树模板解决马踏棋盘问题示例
09-21
在解决马踏棋盘问题时，我们利用回溯法来探索所有可能的马的移动路径，直到找到满足条件的解，即马走遍棋盘上的所有64个方格，且每个方格只进入一次。 马踏棋盘问题源于国际象棋中的马的移动规则，马每一步可以跳跃...
数据结果马踏棋盘代码
12-10
数据结果马踏棋盘代码，自己上机写的，可以完美运行。
C语言实现马踏棋盘
04-12
使用C语言实现的马踏棋盘，利用的贪心算法，效率大大提升
马踏棋盘数据结构c++
12-23
马踏棋盘问题是一个经典的数据结构与算法问题，其本质是在一个给定的棋盘上，将马按照象棋中的走法进行移动，要求每个格子只能经过一次，最终使得马能够踏遍整个棋盘。 在C语言中，可以使用回溯算法来解决马踏棋盘问题。首先，我们需要定义一个二维的棋盘数组来表示棋盘，在棋盘数组中，每个格子的值表示马在该格子上停留的顺序，初始化为-1表示未被访问过。 接下来，通过编写一个递归函数来实现马的移动。在递归函数中，我们首先判断当前位置是否合法，即是否在棋盘范围内且未被访问过，然后依次尝试马的八种走法。如果马能够成功踏遍整个棋盘，则打印出相应的路径；如果不行，则回溯到上一步重新选择。 最后，在主函数中调用递归函数，并初始化棋盘数组，从某个初始位置开始进行搜索，直到找到一条可行的路径或者所有路径尝试完毕。 通过以上实现，我们可以在C语言中解决马踏棋盘问题，并找到所有可能的路径。这不仅能够锻炼我们对数据结构与算法的理解，还能够提高我们的编程技巧和解决问题的能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值