栈的应用--马踏棋盘-DFS搜索

本文介绍了一个经典的马踏棋盘问题实现方案,采用深度优先搜索(DFS)算法寻找马走遍整个8x8棋盘的所有路径,并填充数字标记已走过的每一步。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

问题描述:将马随机放在国际象棋的Board[0~7][0~7]的某个方格中,马按走棋规则进行移动。走遍棋盘上全部64个方格。编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8×8的方阵,输出之。

实现思路:DFS 搜索(因为我们的马要踏遍所有的方格,所以我们在这里不需要visted数组,因为如果我们要判断是否走过的话,完全就可以用棋盘是否等于零来判断,同时也提高了一丢丢效率)

实现代码:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#define ROW  8
#define COL  8

int integer[ROW][COL] ;
int  print(int integer[ROW][COL]);

int dir[8][2]={
    {1,2},{2,1},
    {2,-1},{1,-2},
    {-1,-2},{-2,-1},
    {-2,1},{-1,2}
}  ;     //方向数组,代表 8  个方向

int check(int x,int y)
{
    if(x< 0 || y<0 || x>= ROW || y>= COL || integer[x][y]  !=  0 )    //不是0 ,就不能走了 
        return 0;
    return 1;
}

int dfs(int x,int y ,int step_num)    //已经踏到了  x , y ,即x,y  可踏
{
    int xx,yy ,i ;
    if(step_num == 65 )  //思考一下为什么是65 ?当下面step_num == 63赋值完成后时,step_num === 64 进入dfs ,遇到if 终止程序了,故64并没有被赋值
    {
        print(integer);
        exit(1);
    }
    for(i= 0;i< 8 ;i++)   //  8 个方向 
    {
        xx =  x + dir[i][0];
        yy =  y + dir[i][1];
        if(check(xx,yy))  //xx ,yy 可踏上去
        {
            integer[xx][yy]=step_num;
            dfs(xx,yy,step_num+1) ; //DFS 易错点
            integer[xx][yy]= 0;    //回朔
        }
    }
    return 0;
}
int print(int integer[ROW][COL])
{
    int i,j;
    for(i=0;i<ROW ;i++)
    {
        for(j=0 ;j<COL ;j++)
        {
            printf("%6d",integer[i][j]);
        }
        printf("\n\n");
    }
}
int main(void)
{
    int i,j ;
    memset(integer,0,sizeof(integer));
    integer[0][0]= 1;
    dfs(0,0,2) ; 
}

运行截图:

这里写图片描述

PS :从(0,0)点出发很快,但从其他任何一个点出发都极其的慢,可能得需要几天吧。So,效率可以说是非常的低下了,必须得想其他的办法才行!!

棋盘 链表 按照老师的要求的。大家来下载吧· 但是计算算法比较冗余,计算不较慢。 #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
问题描述:将随机放在国际象棋的 8X8 棋盘中的某个方格中,按走棋规则进行移动。要求每个方格上只进入一次,走遍棋盘部 64 个方格。编制递归程序,求出的行走路线 ,并按求出的行走路线,将数字 1,2,…,64 依次填入 8X8 的方阵输出之。测试数据:由读者指定可自行指定一个的初始位置。实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”悔棋使用。并探讨每次选择位置的“最佳策略”,以减少回溯的次数。 背景介绍: 国际象棋为许多令人着迷的娱乐提供了固定的框架,而这些框架常独立于游戏本身。其中的许多框架都基于骑士奇异的L型移动规则。一个经典的例子是骑士漫游问题。从十八世纪初开始,这个问题就引起了数学家解密爱好者的注意。简单地说,这个问题要求从棋盘上任一个方格开始按规则移动骑士,使之成功的游历国际象棋棋盘的64个方格,且每个方格都接触且仅接触一次。 可以用一种简便的方法表示问题的一个解,即将数字1,……,64按骑士到达的顺序依次放入棋盘的方格中。 一种非常巧妙的解决骑士漫游地方法由J.C.Warnsdorff于1823年给出。他给出的规则是:骑士总是移向那些具有最少出口数且尚未到达的方格之一。其中出口数是指通向尚未到达方格的出口数量。在进一步的阅读之前,你可以尝试利用Warnsdorff规则手工构造出该问题的一个解。 实习任务: 编写一个程序来获得棋盘即骑士漫游问题的一个解。 您的程序需要达到下面的要求: 棋盘的规模是8*8; 对于任意给定的初始化位置进行试验,得到漫游问题的解; 对每次实验,按照棋盘矩阵的方式,打印每个格被行径的顺序编号。 技术提示: 解决这类问题的关键是考虑数据在计算机中的存储表示。可能最自然的表示方法就是把棋盘存储在一个8*8的二维数组board中。以(x,y)为起点时骑士可能进行的八种移动。一般来说,位于(x,y)的骑士可能移动到以下方格之一:(x-2,y+1)、(x-1,y+2)、(x+1,y+2)、(x+2,y+1)、(x+2,y-1)、(x+1,y-2)、(x-1,y-2)、(x-2,y-1)。但请注意,如果(x,y)的位置离某一条边较近,有些可能的移动就会把骑士移到棋盘之外,而这当然是不允许的。骑士的八种可能的移动可以用一个数组MoveOffset方便地表示出来: MoveOffset[0]=(-2,1) MoveOffset[1]=(-1,2) MoveOffset[2]=(1,2) MoveOffset[3]=(2,1) MoveOffset[4]=(2,-1) MoveOffset[5]=(1,-2) MoveOffset[6]=(-1,-2) MoveOffset[7]=(-2,-1) 于是,位于(x,y)的骑士可以移动到(x+MoveOffset[k].x, y+MoveOffset[k].y),其中k是0到7之间的某个整数值,并且新方格必须仍位于棋盘上。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值