小甲鱼数据结构和算法--马踏棋盘(骑士周游问题)

代码如下:

#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<Y;j++){
                    printf("%2d\t",chess[i][j]);
            }
            printf("\n");
        }
}
int next(int *x,int *y,int step){
    switch(step)
    {
        case 0:
            if(*y+2<=Y-1 && *x-1>=0 && chess[*x-1][*y+2]==0)
            {
                *y+=2;
                *x-=1;
                return 1;
            }
            break;
        case 1:
            if(*y+2<=Y-1 && *x+1<=X-1 && chess[*x+1][*y+2]==0)
            {
                *y+=2;
                *x+=1;
                return 1;
            }
            break;
        case 2:
            if(*y+1<=Y-1 && *x+2<=X-1 && chess[*x+2][*y+1]==0)
            {
                *y+=1;
                *x+=2;
                return 1;
            }
            break;
        case 3:
            if(*y-1>=0 && *x+2<=X-1 && chess[*x+2][*y-1]==0)
            {
                *y-=1;
                *x+=2;
                return 1;
            }
            break;
        case 4:
            if(*y-2>=0 && *x+1<=X-1 && chess[*x+1][*y-2]==0)
            {
                *y-=2;
                *x+=1;
                return 1;
            }
            break;
        case 5:
            if(*y-2>=0 && *x-1>=0 && chess[*x-1][*y-2]==0)
            {
                *y-=2;
                *x-=1;
                return 1;
            }
            break;
        case 6:
            if(*y-1>=0 && *x-2>=0 && chess[*x-2][*y-1]==0)
            {
                *y-=1;
                *x-=2;
                return 1;
            }
            break;
        case 7:
            if(*y+1<=Y-1 && *x-2>=0 && chess[*x-2][*y+1]==0)
            {
                *y+=1;
                *x-=2;
                return 1;
            }
            break;
        default:
            break;
    }
    return 0;
}

int horse(int x,int y,int tag){
    int x_t=x,y_t=y;
    int flag=0,count=0;
    chess[x][y]=tag;
    if(tag==X*Y){
        printChess();
        return 1;
    }
    flag=next(&x_t,&y_t,count);
    while(!flag && count<=7){
        count++;
        flag=next(&x_t,&y_t,count);
    }
    while(flag){
        if(horse(x_t,y_t,tag+1))
        return 1;
        x_t=x,y_t=y,count++;
        flag=next(&x_t,&y_t,count);
        while(!flag && count<=7){
            count++;
            flag=next(&x_t,&y_t,count);
        }
    }
    if(!flag)chess[x][y]=0;
    return 0;
}

int main()
{
    int i,j;
    for(i=0;i<X;i++){
        for(j=0;j<Y;j++){
            chess[i][j] = 0;
        }
    }
    clock_t begin,end;
    begin=clock();
    if(!horse(2,0,1)){
        printf("The horse Chess is unavailable!");
    }
    end=clock();
    printf("This time used is %lf\n",(double)(end-begin)/CLOCKS_PER_SEC);
    return 0;
}

运行截图:

时间: 2024-10-06 00:12:57

小甲鱼数据结构和算法--马踏棋盘(骑士周游问题)的相关文章

马踏棋盘(骑士周游问题)

马踏棋盘问题(骑士周游问题) 实际上是图的深度优先搜索(DFS)的应用. 如果使用回溯(就是深度优先搜索)来解决,假如马儿踏了53个点,如图:走到了第53个,坐标(1,0),发现已经走到尽头,没办法,那就只能回退了,查看其他的路径,就在棋盘上不停的回溯-- ,思路分析+代码实现 使用贪心算法(greedyalgorithm)进行优化.解决马踏棋盘问题. /** * 〈马踏棋盘 算法〉 * * @author LZ * @create 2019/9/29 * @since 1.0.0 */ pub

线索二叉树的构建和遍历------小甲鱼数据结构和算法

#include <stdio.h> #include <stdlib.h> typedef char ElemType; // 线索存储标志位 // Link(0):表示指向左右孩子的指针 // Thread(1):表示指向前驱后继的线索 typedef enum {Link, Thread} PointerTag; typedef struct BiThrNode { char data; struct BiThrNode *lchild,*rchild; PointerTag

小甲鱼数据结构和算法-----二叉树的构建和前序遍历

题目要求:建立二叉树并输出每个字符所在的层数.如下图要求输出 A 在第一层 B.C 在第二层 D.E在第三层 代码如下: #include <stdio.h> #include <stdlib.h> typedef struct BiTNode { char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; // 创建一棵二叉树,约定用户遵照前序遍历的方式输入数据 void CreateBiTree(BiTree *T)

回溯算法(马踏棋盘)

近期学习了回溯算法于是自己写了马踏棋盘的递归以及非递归方式的代码: 运行效果如下: (本人水平有限,若有不足之处欢迎大家交流)

马踏棋盘代码分析

(因为最近数据结构讲到图和网,听是能听懂,可是一到代码上,就发现问题很多,因此将马踏棋盘的代码拿出来分析下,貌似有些不对头,其实呢是因为不想写其余的作业,所以找个借口) 说到马踏棋盘,这样说,就是一个8*8的棋盘,指定一个位置,让马走日字,将棋盘上的点全部走完. 先说说思路:首先指定位置,在这个位置的基础上走一个位置,然后再在这个基础上走日字,现在面临一个问题,要是走着走着,突然有一次,就那么的卡住在那里了,怎么走都不行,可是全局看下,会发现,还有空点没有踏到,那么怎么办?看来这条路不通了,那就

马踏棋盘的c语言实现(一.遍历法)

题目很简单呀!!! 在国际象棋的棋盘上,将马随意放置,之后走日字,走完即可. 要求:8×8的棋盘 遍历算法: 可以说是碰运气,当你确定在某一位置时,根据规则你自然有了八种选择,                   2   3          1       4           H           8       6         7   5                                         分别是 X=   {i-2, i-1, i+1, i+2, i+

马踏棋盘问题-贪心(matlab&amp;c++)

1.问题描述 将马随机放在国际象棋的Board[0-7][0-7]的某个方格中,马按走棋规则进行移动,走遍棋盘上全部64个方格.编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8×8的方阵,输出之. 2.matlab代码 clear all clc chessboard=zeros(8);%初始化 DirX=[2 1 -1 -2 -2 -1 1 2];%方向向量 DirY=[1 2 2 1 -1 -2 -2 -1]; stack(1).x=0; stack

逃离大厦第80关与马踏棋盘

今天我在玩一款逃离大厦的解密游戏.在跨越了重重障碍来到了第八十关.这一关很有意思 每次点击都会直接冲到底,要求填满所有空白的地方. 本来很容易,但是很不幸,一旦点击了就不能修改,楼主于是想到了马踏棋盘,终于可以学以致用了于是毫不犹豫 上代码 #include <stdio.h> #include <stdlib.h> #define N 5+2 typedef struct { int a[N][N]; int lstep[4]; int rstep[4]; int cnt; }H

马踏棋盘递归所有解

这次马踏棋盘是用递归实现的,而且可以弄出来所有解,当时电脑跑的最快的都有40多万解了,这个也可以看你电脑cpu好坏,一般超级本跑不动.这是实际上和八皇后是同一种性质的问题,都用到了回溯的思想,有接进行下一个,不行了退回去,在进行尝试.不多说了,直接上代码: #include<stdio.h> #include <stdlib.h> #include<conio.h> #define N 8 int cnt=1; // 记录马的位置 int n=1; int chess[