马踏棋盘(C语言版)——贪心算法详解（栈的应用数据结构）

最新推荐文章于 2024-05-28 18:22:06 发布
最新推荐文章于 2024-05-28 18:22:06 发布
阅读量9.3k 收藏 229
点赞数 42
分类专栏： 数据结构 文章标签： 马踏棋盘 贪心 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43204126/article/details/102728758
版权

文章目录


马踏棋盘是栈的一个十分经典的应用，最基本的完成思路其实就是深度优先搜索(dfs)，是一种十分暴力的处理方式，费时费力还不一定可以得到一个好的结果。使用贪心算法，将每一步，每一步的下一步都进行贪心，便会节省大量的时间，而且成功率十分客观，现就马踏棋盘的一种贪心算法做以下总结

题目

设计一个国际象棋的马踏遍棋盘的演示程序。将马随机放在国际象棋 8x8 棋盘 Board[8][8]的某个方格中，马按走棋规则进行移动。要求每个方格只进入一次，走遍棋盘上全部 64 个方格。编制递归或非递归程序，求出马的行走路线，并按求出的行走路线输出。
（1）将行走路线以坐标的形式输出。
（2）在方阵中输出 1~64 个行走足迹；

数据定义

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define ROW 8
#define COL 8
#define MAX_STEPS ROW*COL

//栈结构体
typedef struct stack{
    int x_adr;      //纵坐标
    int y_adr;      //横坐标
    int direction;  //方向
}HORSE_CHESS_STACK;

//存储路径棋盘
int chess[ROW+1][COL+1];

//下一步方向
//一号
int dir[8][2] = {{2,-1},{-2,-1},{-2,1},{2,1}, 
                 {1,-2},{-1,-2},{-1,2},{1,2}};
//二号
/* int dir[8][2] = {{1,2},{-1,-2},{-2,1},{2,1},
 *                  {2,-1},{1,-2},{-1,2},{-2,-1}}; */

//栈顶
int top;
HORSE_CHESS_STACK Adr_Stack[MAX_STEPS];

//出栈次数
int out_stack;

值得注意的是，结构体中，x_adr 其实是真实的纵坐标，y_adr 其实是真实的横坐标（大家画个数组表示的棋盘，其实就懂了）。这个首先要明确，不然在后面的定义和赋值等操作时，会有很多不便。

程序各函数

//初始化数据
void init();
//debug 打印栈的情况
void print_stack();
//入栈
void push_stack(int x_real,int y_real);
//出栈
void pop_stack();
//标记位置
void mark_chess(int x,int y);
//打印路径
void print_chess_board();
//打印每一步的位置
int t = 1;
void print_steps();
//马踏棋盘（贪心）算法
void run_horse_tanxin();

主要思想

我们算法最核心的部分，是在下一步到底应该如何选择这件事上，主要的贪心思路就是：
我们先判断下一步都有哪些位置可以走，然后我们再判断其可走位置的再下一步，有几个位置可以走，并统计这几个末端位置的在下一步有几个位置可以走。
也就是 分别计算当前位置下下一步的权，之后我们将下下一步的权都加起来，算成下一步的权，并存储到 next 数组里面。
之后，我们建立 real_next 数组，通过查找遍历，依次将 next 中最小元素的下标赋值给 real_next 数组，这样，我们就得到了一个下一步走的方向顺序的数组 real_next。
这时，我们就可以开始按照 real_next 的顺序来走下一步

以下是核心代码(注释已加)：

		//现在位置
        x_now = Adr_Stack[top].x_adr;
        y_now = Adr_Stack[top].y_adr;
    
        //对方向进行排序
        int next[ROW] = {};
        for(int i = 0;i < ROW;i++){
            //下一步坐标
            int x_next = x_now + dir[i][0];
            int y_next = y_now + dir[i][1];
            
            if((x_next > 0 && x_next <= COL) && (y_next > 0 && y_next <= ROW) && chess[y_next][x_next] == 0 ){
                //对下一步的下一步判断是否可以走
                for(int j = 0;j < ROW;j++){
                    int x_next_next = x_next + dir[j][0];
                    int y_next_next = y_next + dir[j][1];

                    //可以走,next 对应下标+1
                    if((x_next_next > 0 && x_next_next <= COL) && (y_next_next > 0 && y_next_next <= ROW) && chess[y_next_next][x_next_next] == 0){
                        next[i]++;
                    }
                }
            }
        }
        
        //依次返回 next 中最小元素的下标，返回后将元素赋值为最大
        int real_next[8] = {0};
        int k = 0;
        int t = ROW + 1;
        for(int i = 0;i < ROW;i++){
            t = ROW + 1;
            for(int j = 0;j < 8;j++){
                if(next[j] < t){
                    real_next[i] = j;
                    t = next[j];
                    k = j;
                }
            }
            next[k] = ROW + 1;
        }

        //走下一步
        int dir_now = 0;
        for(dir_now = Adr_Stack[top].direction + 1;dir_now < ROW;dir_now++){
            int x_real = x_now + dir[real_next[dir_now]][0];
            int y_real = y_now + dir[real_next[dir_now]][1];

            Adr_Stack[top].direction += 1;

            if((x_real <= COL && x_real > 0) && (y_real <= ROW && y_real > 0) && chess[y_real][x_real] == 0){
                //入栈
                push_stack(x_real,y_real);
                //标记棋盘
                mark_chess(x_real,y_real);
                break;
            }
        }

流程图

马踏棋盘——贪心算法主要函数流程图

输出分析

下面环境是Linux Ubuntu 18.04
经过一系列实验输入，最终64个位置，无论是从哪个开始，都可以走完全部棋盘，且大部分情况下，没有出栈回溯的情况
以下是一号方向数组在起始位置是（1,1）所得出的答案：
马踏棋盘，样例一
在一号方向数组中，只有在 8,6这个位置，有回溯发生：
马踏棋盘样例二（有回溯）
我们还应该注意的是，当方向数组的顺序定义得不同时，得到的走的方案也很大可能是不同的
下面，是二号方向数组数组的同样 （1 1）位置所得出的路径
二号方向数组
同时我们通过观察其用时发现，贪心的效率十分可观

源码

注释已加

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define ROW 8
#define COL 8
#define MAX_STEPS ROW*COL

//栈结构体
typedef struct stack{
    int x_adr;      //纵坐标
    int y_adr;      //横坐标
    int direction;  //方向
}HORSE_CHESS_STACK;

//存储路径棋盘
int chess[ROW+1][COL+1];

//下一步方向
//一号
int dir[8][2] = {{2,-1},{-2,-1},{-2,1},{2,1}, 
                 {1,-2},{-1,-2},{-1,2},{1,2}};

//二号
/* int dir[8][2] = {{1,2},{-1,-2},{-2,1},{2,1},
                  {2,-1},{1,-2},{-1,2},{-2,-1}}; */ 

//栈顶
int top;
HORSE_CHESS_STACK Adr_Stack[MAX_STEPS];

//出栈次数
int out_stack;

//初始化数据
void init(){
    int n = MAX_STEPS;
    while(n--){
        Adr_Stack[n].x_adr = 0;
        Adr_Stack[n].y_adr = 0;
        Adr_Stack[n].direction = -1;
    }
    Adr_Stack[0].x_adr = 0;
    Adr_Stack[0].y_adr = 0;
    Adr_Stack[0].direction = -1;
    
    for(int i = 1;i <= ROW;i++){
        for(int j = 1;j <= COL;j++){
            chess[ROW][COL] = 0;
        }
    }
    
    top = -1;
    out_stack = 0;
}

//debug 打印栈的情况
void print_stack(){
    printf("栈的情况:\n");
    for(int i = 0;i < MAX_STEPS;i++){
        printf("x:%d  y:%d direction = %d\n",Adr_Stack[i].y_adr,Adr_Stack[i].x_adr,Adr_Stack[i].direction);
    }
    printf("\n\n");
}

//入栈
void push_stack(int x_real,int y_real){
    top++;
    Adr_Stack[top].x_adr = x_real;
    Adr_Stack[top].y_adr = y_real;
    Adr_Stack[top].direction = -1;  //初始化走的方向
}

//出栈
void pop_stack(){
    Adr_Stack[top].x_adr = 0;
    Adr_Stack[top].y_adr = 0;
    Adr_Stack[top].direction = -1;  //初始化走的方向
    top--;
}

//标记位置
void mark_chess(int x,int y){
    chess[y][x] = top + 1;
}

//打印路径
void print_chess_board(){
    printf("\nroute:\n");
    for(int i = 1;i <= ROW;i++){
        for(int j = 1;j <= ROW;j++){
            printf("%4d ",chess[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

//打印每一步的位置
int t = 1;
void print_steps(){
    printf("(%d,%d)",Adr_Stack[top].y_adr,Adr_Stack[top].x_adr);
    t++;
    if(t == ROW){
        printf("\n");
        t = 0;
    }
}

//马踏棋盘（贪心）算法
void run_horse_tanxin(){
    int x_now,y_now;
    while(1){
        
        //已经走完全图
        if(top >= MAX_STEPS - 1){
            //打印棋盘
            print_chess_board();
            break;
        }

        //现在位置
        x_now = Adr_Stack[top].x_adr;
        y_now = Adr_Stack[top].y_adr;
    
        //对方向进行排序
        int next[ROW] = {};
        for(int i = 0;i < ROW;i++){
            //下一步坐标
            int x_next = x_now + dir[i][0];
            int y_next = y_now + dir[i][1];
            
            if((x_next > 0 && x_next <= COL) && (y_next > 0 && y_next <= ROW) && chess[y_next][x_next] == 0 ){
                //对下一步的下一步判断是否可以走
                for(int j = 0;j < ROW;j++){
                    int x_next_next = x_next + dir[j][0];
                    int y_next_next = y_next + dir[j][1];

                    //可以走,next 对应下标+1
                    if((x_next_next > 0 && x_next_next <= COL) && (y_next_next > 0 && y_next_next <= ROW) && chess[y_next_next][x_next_next] == 0){
                        next[i]++;
                    }
                }
            }
        }
        
        //依次返回 next 中最小元素的下标，返回后将元素赋值为最大
        int real_next[8] = {0};
        int k = 0;
        int t = ROW + 1;
        for(int i = 0;i < ROW;i++){
            t = ROW + 1;
            for(int j = 0;j < 8;j++){
                if(next[j] < t){
                    real_next[i] = j;
                    t = next[j];
                    k = j;
                }
            }
            next[k] = ROW + 1;
        }

        //走下一步
        int dir_now = 0;
        for(dir_now = Adr_Stack[top].direction + 1;dir_now < ROW;dir_now++){
            int x_real = x_now + dir[real_next[dir_now]][0];
            int y_real = y_now + dir[real_next[dir_now]][1];

            Adr_Stack[top].direction += 1;

            if((x_real <= COL && x_real > 0) && (y_real <= ROW && y_real > 0) && chess[y_real][x_real] == 0){
                //入栈
                push_stack(x_real,y_real);
                //标记棋盘
                mark_chess(x_real,y_real);
                break;
            }
        }

        //如果下一步走不了，则出栈回溯
        if(Adr_Stack[top].direction >= 7){
            printf("\n out:(%d,%d) \n",Adr_Stack[top].y_adr,Adr_Stack[top].x_adr);
            chess[Adr_Stack[top].y_adr][Adr_Stack[top].x_adr] = 0;
            //记录出栈次数
            out_stack++;
            pop_stack();
        }
        
        //打印栈
        /* print_stack(); */
        //打印走了以后所处位置
        print_steps();
    }
}

int main(){
    int st_x,st_y;
    while(1){
        printf("Please input: x  y :");
        scanf("%d %d",&st_x,&st_y);
        
        if(st_x > 0 && st_x <= ROW && st_y > 0 && st_y <= COL){
            printf("Get x and y success!\n");
            break;
        }
        
        printf("Input wrong!please input x y again:");
    }
    init();
    /* print_stack(); */
    //获得开始时间
    clock_t start = clock();
    
    //将起始位置入栈
    push_stack(st_x,st_y);
    //标记起始位置
    mark_chess(st_x,st_y);
    
    printf("\nroute address:\n");
    printf("(%d,%d)",st_x,st_y);
    
    //开始算法
    run_horse_tanxin();
    
    //计算结束时间
    clock_t finish = clock();
    double run_time = (double)(finish - start) / CLOCKS_PER_SEC;
    
    printf("Running time：%f seconds  \nOut stack times:%d\n",run_time,out_stack);
}

暴力和简单贪心

总结至此，希望对大家可以有帮助，同时如果大家有兴趣的话，可以看一下朋友的这篇博客，里面讲解了暴力方法和简单贪心。

感谢阅读！

皮蛋瘦肉粥嗷
关注
  • 42
    点赞
  • 踩
  • 229
    收藏
    觉得还不错? 一键收藏
  • 25
    评论
专栏目录
马踏棋盘的贪心算法实现
10-24
VC++实现，生成可视化演示程序 棋盘式的，点一下所有步骤1234.。
算法——马踏棋盘算法（骑士周游问题）/图的深度优先遍历+贪心算法优化
weixin_43713707的博客
04-13 632
马踏棋盘算法也叫骑士周游问题，其要求是：将马随机放在国际象棋的 8×8 棋盘 Board[0～7][0～7]的某个方格中，马按走棋规则()进行移动。要求，走遍棋盘上全部 64 个方格。
骑士周游问题（马踏棋盘）----贪心算法（动态规划补充）
最新发布
Dr_RR的博客
05-28 710
然后就是考虑调用的位置 ：应该在获取ps数组下一个可以走的位置有哪些之后就对这些路线的数量进行排序，而其位置就在traversalChessBoard方法下，在对ps数组进行遍历之前进行排序。//这里一定要放入一个新的p1点，不然会造成p1点的位置一直在变换。比如：下一次走的1号位置和2号位置，1号位置的下一步有两个选择，2号位置下一步有四个选择，那马下一步就走1号位置以减少回溯次数。//这样就把ps数组里的每一个点的下一个位置的多少进行了排序，优先走下一步的下一步的次数少的格子。
数据结构课后习题 马踏棋盘 c语言版
热门推荐
YULIU_的博客
10-20 1万+
将马随机放在国际象棋的8×8棋盘某个方格中， 马按走棋规则进行移动。 要求每个方格只进入一次，走遍棋盘上全部64个方格。记录其步骤 转载的图片#include #include#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10typedef struct //记录坐标位置 { int x;......
c语言数据结构之马踏棋盘
qq_55918164的博客
07-12 1205
c语言数据结构之马踏棋盘
马踏棋盘问题的程序c语言,C语言马踏棋盘
weixin_28856341的博客
05-17 1203
问题描述国际象棋的棋盘为8×8的方格棋盘。现将“马”放在任意指定的方格中，按照“马”走棋的规则将“马”进行移动。要求每个方格只能进入一次，最终使得“马”走遍棋盘的64个方格。编写一个C程序，实现马踏棋盘操作，要求用1〜64这64个数字标注马移动的路径，也就是按照求出的行走路线，将数字1，2，……64依次填入棋盘的方格中，并输出。问题分析国际象棋中，“马”的移动规则如图1所示。○○○○●○○○○图1...
马踏棋盘C语言简单版本实现（内有详细注释）
dom_l_z的博客
05-30 1253
#include <stdio.h> #include <time.h> #define X 5 // 棋盘宽 #define Y 5 // 棋盘高 int chess[X][Y]; // 棋盘 // 打印棋盘 void printChess() { int i, j; printf("This is horse Chess:\n"); for (i = 0; i < X; i++) { for (j = 0; j <
有趣的数据结构算法18——马踏棋盘问题（骑士周游问题）的C语言实现（回溯法）及其解析
Bubbliiiing的学习小课堂
08-19 5356
有趣的数据结构算法18——马踏棋盘问题（骑士周游问题）的C语言实现（回溯法）及其解析问题复述题目分析利用c语言实现马踏棋盘问题GITHUB下载连接 马踏棋盘问题就是要求使用国际象棋的棋子马
贪心算法 --- 马踏棋盘（C）
m0_72495985的博客
12-03 731
而不是去找路径多的，或者是随机的呢，原因就是路劲少的点，到达它的点就少了，如果这次没有选择这个点的话，下次再来这个点就会变得困难，甚至是不可以走了。开始写的一个老是走到一半就会停止了，不能够继续前进了，不知道是什么原因，搞了一晚上的时间，有种把电脑砸了的冲动，最终发现原因竟然是那么简单的，很基础的一点关于c的问题，看来c好久不看，确实是不可以了。初看起来，这些量度标准似乎都是可取的，但实际上，用其中的大多数量度标准作贪婪处理所得到该量度意义下的最优解并不是问题的最优解，而是次优解。
马踏棋盘问题（c语言实现）
m0_47773954的博客
05-22 752
#include <stdio.h> #include <time.h> #define X 8 #define Y 8 int chess[X][Y]; // 找到基于(x,y)位置的下一个可走的位置 int nextxy(int* x, int* y, int count) { switch (count) { case 0: if (*x + 2 <= X - 1 && *y - 1 >= 0 && chess[*x
C语言实现马踏棋盘
Future_LL的博客
04-07 4116
//马踏棋盘主要要考虑三个因素： //第一：马走的位置用Move数组表示，以及棋盘的大小不再是8*8，而是12*12； //第二：只要找到马可以踏的下一个位置，就进行递归，只有一只进行递归，这是一种理想状态； /第三：也是最不好想的一点，如果在当前位置，准备进行下一个位置，但是没有找到，就需要回溯，回溯需要将计数器--，并且将这个位置赋值为0，表示这个位置没走过，因为回溯本身就在for循环中...
马踏棋盘问题（C语言）——基于贪心算法优化的深度优先搜索
03-30
马踏棋盘问题（骑士巡游问题）的基于贪心算法优化深度搜索可视化实现 用c语言实现的，在命令台中会动态的显示棋盘上棋子路径
马踏棋盘C语言的完整算法
01-17
马踏棋盘C语言的完整算法 vs2013下编译运行通过
马踏棋盘C语言贪心算法.c
04-11
马踏棋盘C语言贪心算法 将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格
数据结构之马踏棋盘具体算法实现
12-17
"数据结构之马踏棋盘具体算法实现" 在计算机科学中，马踏棋盘问题是一个经典的算法问题。该问题的目的是让马在棋盘上遍历所有格子，而不重复踏入任何一个格子。这个问题可以用来考察算法设计和数据结构的应用。本文...
数据结构与算法｜马踏棋盘算法（小甲鱼）C语言代码的算法分析
峰峰的博客
03-03 3112
马踏棋盘算法（骑士周游问题）的算法分析 C语言代码部分来自小甲鱼的《数据结构与算法》 题目要求： ​ 国际象棋的棋盘为8*8的方格棋盘，现将“马”放在任意指定的方格中，按照“马”走棋的规则将“马”进行移动。要求每个方格只能进入一次，最终使得“马”走遍棋盘64个方格。 马踏棋盘的一个解： 对于在n*n的棋盘上，当n>=5且为偶数的时候，以任意点作点都有解。 回溯法：一条路走到黑，碰壁了...
c语言马踏棋盘编程分析,马踏棋盘的递归算法（c语言）
weixin_33966205的博客
05-18 303
#include#include#includeintm,n;//棋盘大小intc[100][100];intdy[]={2,1,-1,-2,-2,-1,1,2};intdx[]={1,2,2,1,-1,-2,-2,-1};intjudge(intx,inty)//判断是否在棋盘上{if(x>0&&x<=m&&y>0&&amp...
贪心算法马踏棋盘c语言,马踏棋盘：一个贪心算法实例
weixin_39649736的博客
05-23 426
问题描述：在8×8方格(国际象棋)的棋盘上，从任意指定方格出发，为马寻找一条走遍棋盘每一格并且只经过一次的一条路径问题分析：首先这是一个搜索问题，运用深度优先搜索进行求解是完全可行的，它输入的是全部解，但是马遍历当8×8时解是非常之多的，用天文数字形容也不为过，这样一来求解的过程就非常慢，并且出一个解也非常慢。怎么才能快速地得到部分解呢？其实马踏棋盘的问题很早就有人提出，且早在1823年，J.C....
[C语言][数据结构]马踏棋盘问题
weixin_52192405的博客
09-23 2302
将马放入国际象棋8×8棋盘的制定的某个方格中，马按走棋规则进行移动，要求每个方格只进入一次，走遍棋盘上全部64个方格。求出马的行走路线，并按求出的行走路线将数字1，2，…，64依次填入一个8×8的方阵并输出。
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值