马踏棋盘数据结构实践报告

合集下载

数据结构 马踏棋盘 设计报告

数据结构 马踏棋盘 设计报告

《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目:姓名:院系:专业:年级:学号:指导教师:2011年月日目录1、程序设计的目的2、设计题目3、分析4、设计思想5、算法6、测试结果7、调试分析8、小结1、课程设计的目的1、熟练使用C++语言编写程序,解决实际问题;2、了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;3、初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;4、提高综合运用所学的理论知识和方法独立分析和解决问题的能力;5、学习并熟悉栈的有关操作;6、利用栈实现实际问题;2、设计题目【马踏棋盘】*问题描述:将马随机放在国际象棋的8X8棋盘Bo阿rd[0..7,0..7]的某个方格中,马按走棋规则进行移动。

要求每个方格上只进入一次,走遍棋盘上全部64个方格。

编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入8X8的方阵输出之。

*测试数据:由读者指定,可自行指定一个马的初始位置。

*实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。

并探讨每次选择位置的“最佳策略”,以减少回溯的次数。

3、分析确定输入值的范围,输入马的初始行坐标X和Y,X和Y的范围都是1到8之间。

程序的功能是输出马走的步骤,要使马从任一起点出发,通过程序能找到下一个地点,然后遍历整个棋盘。

每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。

并探讨每次选择位置的“最佳策略”,以减少回溯的次数。

输出时可以用二维数组。

4、设计思想输入马初始位置的坐标。

将初始位置进栈,经过一个while循环,取出符合条件的栈顶元素。

利用函数,找出栈顶元素周围未被占用的新位置,如果有,新位置入栈;否则弹出栈顶元素。

第七次实验 马踏棋盘问题

第七次实验  马踏棋盘问题
桂林电子科技大学
数学与计算科学学院综合性、设计性实验报告
实验室:06406实验日期:2015年05月29日
院(系)
信息与计算科学系
年级、专业、班
1300710226
姓名
庞文正
成绩
课程
名称
数据结构实验
实验项目
名 称
马踏棋盘问题
指导
教师
教师
评语
教师签名:
年 月 日
一 ,实验目的
加深对图的理解,培养解决实际问题的编程能力。根据数据对象的特性,学会数据组织的方
start.y--;
curstep=1; //第一步
Move(start); //求解
}
五,实验结果分析或总结
运行半天不出来,比如输入 2 2还以为算法有误,后来想通了,真开心!
{n");
scanf("%d%d",&start.x,&start.y);
}
else
{
break;
}
}
for(i=0;i<8;i++) //初始化棋盘个单元位置
{
for(j=0;j<8;j++)
{
chessboard[i][j]=0;
}
}
start.x--;
格子具有集合性,故考虑使用无向图来表示格子及其间关系;以邻接表作为该无向图中结点与相邻8个结点(4黑4白)的存储结构;以顶点表存储格子,每格为顶点表中一结点,其指针域指向该顶点所能到达的第一个结点。
表头结点:
Vex
x
y
link
Vex:头结点所在的序号
x:头结点所在的横坐标;

棋盘算法实验报告(3篇)

棋盘算法实验报告(3篇)

个人自我介绍简单大方
很抱歉,但我无法为您提供____字的自我介绍。

以下是一个简洁而大方的自我介绍示例,供您参考:
大家好,我叫[姓名]。

很高兴有机会向大家介绍一下自己。

我出生并长大在[所在地],是一个勤奋、积极向上的人。

在学业方面,我于[毕业时间]从[学校名称]获得了[学位/专业]学位。

在大学期间,我通过自我努力和课外学习,取得了良好的学术成绩,并参与了一些学生组织和社团活动。

这些经历不仅培养了我的团队合作和领导能力,也加强了我的沟通和组织能力。

在工作方面,我有[工作年限]年的相关工作经验。

我曾在[公司/组织名称]担任[职位],负责[工作职责]。

在这期间,我不断努力提升自己的专业知识和技能,以适应快速发展的工作环境。

我善于分析问题并找出解决方案,能够有效地与团队合作并承担责任,这些都为我赢得了同事和上级的认可。

除了工作,我也积极参与志愿者活动,希望能为社区和弱势群体做一点贡献。

我相信,通过奉献和关心他人,我们可以建立一个更加和谐和温暖的社会。

在个人生活中,我喜欢阅读、旅行和运动。

阅读扩展了我的视野,旅行让我能够体验不同的文化和风景,而运动则让我保持健康和积极的精神状态。

此外,我也很喜欢与家人和朋友相处,分享彼此的喜怒哀乐。

总的来说,我是一个热情、乐观、有责任心的人。

我相信勤奋和坚持可以取得成功,而真诚和善良可以赢得他人的信任和支持。

我希望能够在您的团队中发挥我的才能,并与大家一同成长和进步。

这就是我简单的自我介绍,谢谢大家!。

马踏棋盘 数据结构实践报告

马踏棋盘 数据结构实践报告

马踏棋盘问题摘要:马踏棋盘就是在国际象棋8X8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。

理解栈的“后进先出”的特性以及学会使用回溯。

关键字:马踏棋盘、递归、栈、回溯1.引言马踏棋盘就是在国际象棋8X8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。

编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2….64依次填入一个8X8的方阵,并输出它的行走路线。

输入:任意一个起始位置;输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线。

2.需求分析(1)需要输出一个8X8的棋盘,可以采用二维数组的方法实现。

(2)输入马的起始位置,必须保证输入的数字在规定范围内,即0<=X<=7,0<=Y<=7。

(3)保证马能走遍整个棋盘,并且不重复。

(4)在棋盘上输出马的行走路线,标记好数字1、2、3直到64。

3.数据结构设计采用栈数组为存储结构。

#define maxsize 100struct{int i;int j;int director;}stack[maxsize];4.算法设计4.1 马的起始坐标void location(int x,int y) //马的位置坐标的初始化{top++;stack[top].i=x; //起始位置的横坐标进栈stack[top].j=y; //起始位置的竖坐标进栈stack[top].director=-1;a[x][y]=top+1; //标记棋盘Try(x,y); //探寻的马的行走路线}4.2 路径探寻函数void Try(int i,int j){ int count,find,min,director;int i1,j1,h,k,s;intb[8]={-2,-2,-1,1,2,2,1,-1},c[8]={1,-1,-2,-2,-1,1,2,2};//存储马各个出口相对当前位置行、列坐标的增量数组int b2[8],b1[8];for(h=0;h<=7;h++)//用数组b1[8]记录当前位置的下一个位置的可行路径的条数{ count=0;i=stack[top].i+c[h];j=stack[top].j+b[h];if(i>=0&&i<=7&&j>=0&&j<=7&&a[i][j]==0)//如果找到下一个位置{for(k=0;k<=7;k++){i1=i+c[k];j1=j+b[k];if(i1>=0&&i1<=7&&j1>=0&&j1<=7&&a[i1][j1]==0) //如果找到下一个位置count++; //记录条数}b1[h]=count; //将条数存入b1[8]中}}for(h=0;h<=7;h++)//根据可行路径条数的大小,从小到大排序,并放入数组b2[8]中{min=9;for(k=0;k<=7;k++)if(min>b1[k]){min=b1[k];b2[h]=k;s=k;}b1[s]=9;}find=0;director=stack[top].director;for(h=director+1;h<=7;h++)//向8个方向进行寻找{i=stack[top].i+c[b2[h]];j=stack[top].j+b[b2[h]];if(i>=0&&i<=7&&j>=0&&j<=7&&a[i][j]==0){stack[top].director=h; //存储栈的寻找方向top++; //进栈stack[top].i=i;stack[top].j=j;stack[top].director=-1;//重新初始化下一栈的方向a[i][j]=top+1;find=1; //找到下一位置break;}}if(find!=1){a[stack[top].i][stack[top].j]=0; //清除棋盘的标记top--; //退栈}if(top<63)Try(i,j); //递归}4.3输出函数void display(){int i,j;for(i=0;i<=7;i++){ for(j=0;j<=7;j++)printf("\t%d ",a[i][j]); //输出马的行走路线printf("\n\n");}printf("\n");}5.程序实现5.1 主函数void main(){int i,j,x,y;for(i=0;i<=7;i++) //棋盘的初始化for(j=0;j<=7;j++)a[i][j]=0;printf("输入X Y (0=<X<=7,0=<Y<=7)\n");scanf("%d%d",&x,&y);if(x>=0&&x<=7&&y>=0&&y<=7)//判断输入的起始位子是否正确{location(x,y);display();}else printf("错误\n");}5.2运行结果(1)当输入不符合要求时(2)正确输入时5.3 算法分析(1)马的起始坐标一开始先建立一个栈数组,里面包括横坐标和竖坐标还有方向。

实验报告马踏棋盘

实验报告马踏棋盘

2.4题马踏棋盘题目:设计一个国际象棋的马踏棋盘的演示程序班级::学号:完成日期:一.需求分析(1)输入的形式和输入值的围:输入马的初始行坐标X和列坐标Y,X和Y的围都是[1,8]。

(2)输出形式:以数组下表的形式输入,i为行标,j为列标,用空格符号隔开。

以棋盘形式输出,每一格打印马走的步数,这种方式比较直观(3)程序所能达到的功能:让马从任意起点出发都能够遍历整个8*8的棋盘。

(4)测试数据,包括正确输入及输出结果和含有错误的输入及其输出结果。

数据可以任定,只要1<=x,y<=8就可以了。

正确的输出结果为一个二维数组,每个元素的值表示马行走的第几步,若输入有错,则程序会显示:“输入有误!请重新输入……”并且要求用户重新输入数据,直至输入正确为止。

二.概要设计(1)、位置的存储表示方式(2) typedef struct {int x;int y;int from;}Point;(2)、栈的存储方式#define STACKSIZE 70#define STACKINCREASE 10typedef struct Stack {Point *top;Point *base;int stacksize;};(1)、设定栈的抽象数据类型定义: ADT Stack {数据对象:D={ai | ai∈ElemSet,i=1,2,…,n,n≥0}数据关系:R1={<ai-1 , ai>|ai-1, ai∈D,i=2,…,n} 约定an端为栈顶,ai端为栈顶。

基本操作:InitStack(&s)操作结果:构造一个空栈s,DestroyStack(&s)初始条件:栈s已存在。

操作结果:栈s被销毁。

ClearStack(&s)初始条件:栈s已存在。

操作结果:栈s清为空栈。

StackEmpty(&s)初始条件:栈s已存在。

操作结果:若栈s为空栈,则返回TRUE,否则返回FALSE。

数据结构课程设计(马踏棋盘)

数据结构课程设计(马踏棋盘)

中南民族大学数据结构课程设计报告姓名:康宇年级: 2010学号: 10061014专业:计算机科学与技术指导老师:宋中山2013年4月15日实习报告:2.4题 马踏棋盘题目:设计一个国际象棋的马踏棋盘的演示程序班级:计科一班 姓名:康宇 学号:10061014 完成日期:2013.4.15 一、需求分析1、国际象棋的马踏棋盘的功能是:将马随机放在国际象棋的N*N 棋盘board[N][N]的某个方格中,马按走棋规则进行移动。

要求每个方格只进一次,走遍棋盘上全部N*N 个方格。

编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,...,N*N 依次填入一个N*N 的方阵,输出之。

2、测试数据:N 由读者指定。

马开始的位置也有读者指定(x,y ),1<=x<=N,1<=y<=N.3、实现提示:下图显示了N 为6,马位于方格(3,3),8个可能的移动位置。

一般来说,马位于位置(x ,y )时,可以走到下列8个位置之一。

但是,如果(x,y )靠近棋盘的边缘,上述有些位置可能超出棋盘范围,成为不允许的位置。

8个可能的位置可以用两个一维数组hi[0...7],hj[0...7]来表示:1 2 3 4 5 6二、概要设计为实现上述程序功能,应用栈Stack[Max*Max]来表示棋盘的行和列。

定义棋盘的规格N,马在下一步可以走的8个位置,hi[0...7],hj[0...7],用数组board[Max][Max]来标记棋盘,top 标记栈指针。

用户在输入了期盼的规格和起始坐标后,程序通过八个方向的探寻,123456输出第一个符合要求的棋盘,棋盘上显示了马每一步的位置,每一个位置只踏了一次,且踏遍棋盘。

1、元素类型(栈):struct Stack{int i; //行坐标int j; //列坐标} stack[Max][ Max];2、建立三个全局位置数组:int hi[8]={-2,-1,1,2,2,1,-1,-2};int hj[8]={1,2,2,1,-1,-2,-2,-1};用来存放下一个可能位置的横纵坐标;int board[Max][Max];用来标记棋盘。

数据结构课程设计实习报告-马踏棋盘

数据结构课程设计实习报告-马踏棋盘

数据结构课程设计实习报告题目:马踏棋盘(实习题 2.4 )班级:计算机科学与技术2004 班学031010151552010号:姓游尾妹名:日期:二OO五年七月八日指导老师:李杨老师源程序结构1. 定义函数caculate () 计算各点的权值dirctions () 求出各点的最佳方向序列,即优先向权值小的方向,以使运行速度加快 check (int i,int j ) 检查( i,j )是否在棋盘内print () 输出路径走过的序号2. 程序步骤简介(1) 计算各点的权值,方向(2) 用户输入行数和列数(3) 寻找点的八个可走方向,若所有方向都已走过,则退回前一步,并将此步 抹去,使前一步的方向发生变化。

( 4) 确定下一步该走的方向,依次走完全部点(5) 记录每一步(6) 当步数已满时输出,根据需要可输出一条或多条路径3. 源程序描述#include "stdio.h" #define N 8int w=0; /* 第几条可走路径 */int way1[8]={-2,-1,1,2, 2, 1,-1,-2};int way2[8]={ 1,2, 2,1,-1,-2,-2,-1}; /*在( i,j )位置处的 8 个可能走的位置 */ int ch[N*N]={0}; /*走过的相应的点的赋值 */int a[N*N+1][3]={0}; /* 路径所经过点的记录 */int dir[N][N][8];/* ( i,j )点的八个可能走的方向 */ int st=1; /* 走过的步数 *//* 每个点的权值 *//* 计算各点的权值 */ 求出各点的最佳方向序列,即优先向权值小的方向 /* 输出路径走过的序号 */ /* /*检查(i,j )是否在棋盘内*/ 计算各点的权值,将权值存在 weight[i][j] 中*//*int i,j,k;for(i=1;i<=N;i++)for(j=1;j<=N;j++) for(k=0;k<N;k++)char c='y'; int weight[N][N]; void caculate(); voiddirctions(); voidprint(); intcheck(int i,int j);void caculate() { */int x,y;x=i+way1[k];y=j+way2[k]; /* 下一步走的点 */if(x>=1&&x<=N&&y>=1&&y<=N)weight[i-1][j-1]++; /*权值 */ }}int check(int i,int j) /*检查 (i,j) 是否在棋盘内,在返回 1,不在返回 {if(i<1||i>8||j<1||j>8)return 0;return 1;}void directions() /* 求出各点的最佳方向序列,即优先向权值小的方向 {int i,j,k,m,n1,n2,x1,y1,x2,y2,way_1,way_2; for(i=0;i<N;i++)0*/ */ for(j=0;j<N;j++){ for(k=0;k<8;k++)dir[i][j][k]=k; for(k=0;k<8;k++) for(m=k+1;m<8;m++) { way_1=dir[i][j][k]; x1=i+way1[way_1];y1=j+way2[way_1];way_2=dir[i][j][m]; x2=i+way1[way_2];y2=j+way2[way_2];n1=check(x1+1,y1+1); n2=check(x2+1,y2+1);{/* 对每个方向考察看有没有更好的*//*k 方向时的下一个点 *//*m 方向时的下一个点 *//*判断 n1,n2 是否在棋盘内*/if(( n1==0 && n2)||( n1 && n2&&weight[x1][y1]>weight[x2][y2])) 到,而 m 方向可达到 */ || /*都可达到,但 m 方向权值小 *//*k 方向不可达 { dir[i][j][k]=way_2;dir[i][j][m]=w ay_1; 即权值小的一步) *//* 交换两个方向值,将 k 走更好的一步棋 }}void print() /* 输出路径走过的序号 */ {int x,y;printf("\n - %d answer --- \n",++w); for(x=1;x<N+1;x++) /*输出是第 w 条路径的序号 */printf("\n");printf("\n");}printf("\nPress n to quit ,press any other key to continue.\n"); c=getchar(); /* 询问是否继 续输出结果 */}main(){int x,y,way,way0; caculate();directions();printf("Please enter the row and column of the starting point.\n");scanf("%d,%d",&a[1][0],&a[1][1]); /* 输入行数和列数 */getchar();y=a[st][1];ch[(x-1)*N+y-1]=0; /* 将这一点被走过的痕迹抹去 */a[st][0]=a[st][1]=a[st][2]=0;a[st-1][2]++; /* 将上一次走的点走的方向发生变化 */st--; /* 步数减一 */}else /* 此点的八个方向未全走过,应走此方向 */{way0=a[st][2];a[st][2]++; /* 确定下次应走的方向 */ x=a[st][0];y=a[st][1]; way=dir[x-1][y-1][way0];x=a[st][0]+way1[way];y=a[st][1]+way2[way]; /* 确定按这次的方向走应走到的 x,y 坐标 */ if(x<1||y<1||x>N||y>N||ch[(x-1)*N+y-1]!=0)continue; /* 此点不满足要求 */ a[st][0]=x; a[st][1]=y;a[st][2]=0; if(st==N*N){ p rint(); /* 标记这一点*//* 步数已满 *//* 输出结果 */if(c=='n')break; a[st][0]=a[st][1]=a[st][2]=0;a[st-1][2]++;}}}}二、 程序运行结果 for(y=1;y<N+1;y++)printf("%2d ",ch[(x-1)*N+y-1]); x=a[1][0],y=a[1][1];ch[(x-1)*N+y-1]=1; while(1){if(a[1][2]>=8)break; if(a[st][2]>=8) { x=a[st][0]; /*在 ch 数组中对相应点赋值,即输出时用到的各点的顺序号/* 出发点的八个方向都已走过,表示所有的方法均已找出 此点的八个方向都已走过,应该退回到上一次走的点 */ */ */ ch[(x-1)*N+y-1]=++st; /* 走到这一点 */ch[(x-1)*N+y-1]=0;例如:输入数值为2,3 时,并且要求输入第2条路径(只按回车键即可)Please enter the row and column of the starting point.2,3---- 1 answer --2 29 54 15 12 31 56 1753 14 1 30 55 16 11 3228 3 52 13 64 61 18 5751 46 63 60 39 58 33 104 27 50 45 62 37 40 1949 24 47 38 59 44 9 3426 5 22 43 36 7 20 4123 48 25 6 21 42 35 8Press n to quit ,press any other key to continue.---- 2 answer --2 29 54 15 12 31 60 1753 14 1 30 55 16 11 3228 3 52 13 64 61 18 5951 46 63 56 39 58 33 104 27 50 45 62 37 40 1949 24 47 38 57 44 9 3426 5 22 43 36 7 20 4123 48 25 6 21 42 35 8Press n to quit ,press any other key to continue.。

利用顺序栈或循环队列的存储来实现马踏棋盘的算法

利用顺序栈或循环队列的存储来实现马踏棋盘的算法

河南工业大学实验报告课程数据结构实验名称利用顺序栈或循环队列的存储来实现马踏棋盘的算法学院信息科学与工程学院专业班级姓名学号实验报告日期 2009 年 4 月 1 日教师审批签字实验报告一实验题目:马踏棋盘二实验要求:将马放在国际象棋的8*8棋盘Board[8][8]的某个方格中,马按走棋的规则进行移动。

要求每个方格只能进入一次。

走遍棋盘上的全部的64个方格。

输入:任意一个起始位置.输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线.数据结构要求:采用顺序栈或者链栈实现三实验目的:1熟悉栈的定义和栈的基本操作2 熟悉每一种栈操作的一般函数实现和成员函数实现。

3在实际问题背景下灵活运用它们,并巩固这两种结构的构造方法四程序设计如下:#include "stdio.h"#define M 70#define FALSE 0#define TRUE 1typedef struct node //结点的类型{int vec,x,y;struct node *link;}listnode;#define MAXSIZE 70typedef struct{int stack[MAXSIZE];int top;}seqstack;seqstack *s; //顺序栈指针listnode ag[M];int flag[M];void setnull(seqstack *s){s->top=-1;}int push(seqstack *s,int x){if(s->top>=MAXSIZE-1){printf("stack overflow!\n");return FALSE;}else{s->stack[++s->top]=x;/*栈顶指针上移,数据元素入栈*/ return TRUE;}}int pop(seqstack *s)/*出当前栈S的栈顶元素*/{ int p;if(s->top<0){printf("stack empty!\n");/*栈空,返回空值 */ return NULL;}else{s->top--;return(s->stack[s->top+1]);}/*由于return语句的特点,必须先使top减1,然后再执行return语句。

数据结构课程设计-马踏棋盘实验报告(仅供参考)

数据结构课程设计-马踏棋盘实验报告(仅供参考)

一、问题描述问题描述:将马随机放在国际象棋的8X8棋盘Bo阿rd[0..7,0..7]的某个方格中,马按走棋规则进行移动。

要求每个方格上只进入一次,走遍棋盘上全部64个方格。

编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入8X8的方阵输出之。

测试数据:由读者指定,可自行指定一个马的初始位置。

实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。

并探讨每次选择位置的“最佳策略”,以减少回溯的次数。

二、实验目的熟练使用栈和队列解决实际问题;(1)了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;(2)初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;(3)提高综合运用所学的理论知识和方法独立分析和解决问题的能力;三、设计过程算法设计思想:根据分析先建了2个结构体struct PosType //马的坐标位置类型{int m_row; //行值int m_col; //列值};struct DataType //栈的元素类型8 17 26 35 4{PosType seat; //马在棋盘中的“坐标位置”int di; //换方向的次数};chess::chess()bool chess::chessPath(PosType start) //在棋盘中进行试探寻找下一步位置并同时记录位置,以及涉及到的入栈出栈void chess::Print() //打印马走的路径PosType chess::NextPos(PosType a,int di)//根据当前点的位置a和移动方向di,试探下一位置(1)、位置的存储表示方式typedef struct{int x;int y;int from;}Point;(2)、栈的存储方式#define STACKSIZE 70#define STACKINCREASE 10typedef struct Stack{Point *top;Point *base;int stacksize;};(3)设定栈的抽象数据类型定义:ADT Stack {数据对象:D={a i | a i∈ElemSet,i=1,2,…,n,n≥0}数据关系:R1={<a i-1 , a i>|a i-1, a i∈D,i=2,…,n}约定a n端为栈顶,a i端为栈顶。

马踏棋盘实习报告

马踏棋盘实习报告

一、实习背景马踏棋盘问题是一个经典的算法问题,也是数据结构课程中的一个重要实验。

通过对马踏棋盘问题的研究和实现,可以加深对栈和队列这两种抽象数据类型的理解,提高算法设计能力和编程能力。

本次实习旨在通过编程实现马踏棋盘问题,并分析其算法的复杂度和优化策略。

二、实习目的1. 理解马踏棋盘问题的背景和意义;2. 掌握栈和队列的应用,以及它们在解决实际问题中的作用;3. 提高算法设计能力和编程能力;4. 分析马踏棋盘问题的算法复杂度,并尝试优化算法。

三、实习内容1. 马踏棋盘问题介绍马踏棋盘问题是指在8x8的国际象棋棋盘上,将一匹马随机放在棋盘上的一个位置,然后按照国际象棋的走法,即“日”字形移动,使得马能够走遍棋盘上的所有方格。

要求使用非递归的方式实现。

2. 栈和队列的应用在解决马踏棋盘问题时,我们可以使用栈来存储马走过的路径,使用队列来实现广度优先搜索(BFS)策略,以寻找马的所有可能走法。

3. 算法实现(1)初始化棋盘和路径栈首先,我们需要初始化一个8x8的二维数组来表示棋盘,并将起始位置设置为(0,0)。

同时,创建一个栈来存储马走过的路径。

(2)定义马的移动规则根据国际象棋的规则,马可以走到以下八个位置之一:(-2,-1),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1)在实现时,我们需要判断这些位置是否在棋盘范围内,以及是否已经走过。

(3)广度优先搜索使用队列来实现广度优先搜索策略,从起始位置开始,按照BFS的顺序,依次尝试马的所有可能走法。

每走一步,就将新的位置压入栈中,并更新队列。

(4)输出结果当队列中所有位置都尝试过一遍后,栈中的路径即为马的行走路线。

按照路径输出棋盘上的数字,即可得到最终结果。

4. 算法优化为了提高算法的效率,我们可以考虑以下优化策略:(1)使用邻接矩阵来表示棋盘,减少重复计算;(2)在遍历队列时,优先考虑距离起始位置较近的位置;(3)在遍历过程中,避免重复访问已经访问过的位置。

马踏棋盘课程设计实验报告

马踏棋盘课程设计实验报告

马踏棋盘课程设计实验报告《数据结构》课程设计实验报告课程名称: 《数据结构》课程设计课程设计题目: 马踏棋盘姓名: 邱可昉院系: 计算机学院专业: 计算机科学与技术班级: 10052313 学号: 10051319 指导老师: 王立波2012年5月18日1目录1.课程设计的目的...............................................................3 2.问题分析........................................................................3 3.课程设计报告内容 (3)(1)概要设计 (3)(2)详细设计 (3)(3)测试结果 (5)(4)程序清单...............................................................6 4.个人小结 (10)21.课程设计的目的《数据结构》是计算机软件的一门基础课程,计算机科学各领域及有关的应用软件都要用到各种类型的数据结构。

学好数据结构对掌握实际编程能力是很有帮助的。

为了学好《数据结构》,必须编写一些在特定数据结构上的算法,通过上机调试,才能更好地掌握各种数据结构及其特点,同时提高解决计算机应用实际问题的能力。

2.问题分析*问题描述:将马随机放在国际象棋的8X8棋盘Bo阿rd[0..7,0..7]的某个方格中,马按走棋规则进行移动。

要求每个方格上只进入一次,走遍棋盘上全部64个方格。

编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入8X8的方阵输出之。

*测试数据:由读者指定,可自行指定一个马的初始位置。

*实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。

并探讨每次选择位置的“最佳策略”,以减少回溯的次数。

马踏棋盘的实习报告

马踏棋盘的实习报告

马踏棋盘的实习报告实习报告:马踏棋盘一、实习单位及实习岗位简介实习单位:ABC软件公司实习岗位:算法工程师助理二、实习内容和任务作为算法工程师助理,我的主要任务是协助开发团队完成一个名为“马踏棋盘”的小游戏的设计和实现。

该游戏是基于棋盘上的骑士的移动规则进行设计的。

具体任务及完成情况如下:1.学习和理解“马踏棋盘”游戏的规则。

在开始设计游戏之前,首先需要深入了解和理解“马踏棋盘”的规则。

通过查阅相关资料和与开发团队成员的讨论,我对游戏规则有了初步的认识和理解。

2.设计游戏的棋盘和角色。

根据游戏规则的要求,我与开发团队成员一起设计和绘制了游戏的棋盘和角色。

棋盘采用8*8的方格,并且在其中的随机位置放置了一些障碍物,增加游戏的难度和挑战性。

角色则是一个具有代表骑士的形象的图标。

3.实现骑士的移动和规则判断。

在游戏中,骑士可以根据特定的移动规则在棋盘上移动。

根据游戏规则的要求,我编写了相应的算法,实现了骑士的移动和规则判断的功能。

通过这个功能,用户可以通过点击棋盘上的方格,移动骑士来完成游戏的目标。

4.添加游戏的界面和交互。

除了基本的游戏功能以外,我们还为游戏设计了用户友好的界面和交互。

通过游戏界面,用户可以清楚地看到棋盘和角色的位置,并且可以通过点击方格或者使用方向键来控制骑士的移动。

同时,我们还添加了计时器和得分系统,提升了游戏的趣味性和挑战性。

5.进行游戏的测试和优化。

为了确保游戏的稳定性和良好的体验效果,我们进行了多轮的测试和优化。

通过不断地发现和修复bug,我们最终完成了一个可以正常运行、界面友好、操作流畅的游戏。

三、实习收获和体会在这次实习中,我通过与开发团队的合作,深入了解了算法在游戏开发中的应用。

通过参与“马踏棋盘”游戏的设计和实现,我不仅加深了对算法和数据结构的理解,在实践中熟悉了常用的算法编程技巧,还提升了团队协作和解决问题的能力。

通过这次实习,我深刻体会到了算法在实际项目中的重要性和应用价值。

马踏棋盘的实习报告

马踏棋盘的实习报告

马踏棋盘实习报告题目:设计一个国际象棋的马踏遍棋盘的演示程序班级:姓名:学号:完成日期:一.需求分析将马随机放在m*n棋盘Board[m][n]的某个方格中,马按国际象棋行棋的规则进行移动。

要求每个方格只行走一次,走遍棋盘上全部m*n个方格。

编写非递归程序,求出马的行走路线,并按求出的行走路线,将数字1, 2, . m*n依次填入-一个m*n的方阵中。

程序要求:在国际象棋8×8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。

编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8×8的方阵,并输出它的行走路线。

输入:任意一个起始位置;输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线。

二.概要设计棋盘可用二维数组表示,马踏棋盘问题可采用回溯法解题。

当马位于棋盘某-位置时,它有唯一坐标,根据国际象棋的规则,它 6 7有8个方向可跳,对每一方向逐探测,从中选择可行方向继续行棋,每一行棋坐标借助栈记录。

若8个方向均不可行则借助栈回溯,在前一位置选择下一可行方向继续行棋,直至跳足m*n步,此时成功的走步记录在栈中。

或不断回湖直至栈空失败。

关于栈的抽象数据类型定义:否则返回ERRORPushStack( &s,SElemType e);操作结果:插入元素e为新的栈顶元素PopStack (&s,SElemType &e);操作结果:若栈不空,则删除s的栈顶元素,并用e返回其值,并返回OK;否则返回ERROR本程序包含以下模块:主程序模块:void main(){定义变量;接受命令;处理命令;退出;}起始坐标函数模块——马儿在棋盘上的起始位置;搜索路径函数模块——马儿每个方向进行尝试,直到试完整个棋盘;输出路径函数模块——输出马儿行走的路径模块调用关系:函数调用关系:三.详细设计#define OK 1#define TRUE 1#define ERROR 0#define FALSE 0#define M 8#define N 8int direction[2][9]={{0,-2,-1,1,2,2,1,-1,-2},{0,1,2,2,1,-1,-2,-2,-1}}; //增量数组int pow[M][N];int check[M][N],next[M][N]; //创建棋盘,初始为0struct Element //数据域{int x,y; //x行,y列int d; //下一步的方向};typedef struct LStack //链栈}*PLStack;typedef struct check //定义棋盘内点的坐标{int x;int y;}Check;/*************栈函数****************/ int InitStack(PLStack &S)//构造空栈{S=NULL;return OK;}int StackEmpty(PLStack S)//判断栈是否为空{if(S==NULL)return OK;elsereturn FALSE;}int Push(PLStack &S, Element e)//元素入栈PLStack p;p=(PLStack)malloc(sizeof(LStack));p->data=e;p->next=S;S=p;return OK;}int Pop(PLStack &S,Element &e) //元素出栈{PLStack p;if(!StackEmpty(S)){e=S->data;p=S;S=S->next;free(p);return OK;}/********贪心权值函数********/void Printf(int p[M][N]){ //打印权值数组for(int i=0;i<M;i++){for(int j=0;j<N;j++)printf(" %2d ",p[i][j]);printf("\n");}}void InitWeight(){ //创建权值数组并初始化每个位置的权值for(int i=0;i<M;i++)for(int j=0;j<N;j++)pow[i][j]=0;for(int i=0;i<M;i++){for(int j=0;j<N;j++){for(int dir=1;dir<=8;dir++){int x1=i+direction[0][dir];int y1=j+direction[1][dir];if(x1>=0&&x1<=7&&y1>=0&&y1<=7)pow[i][j]++;}}}}void SetWeight(int x,int y) { //位置(x,y)设置为被占用时,修改权值数组,被占用时为9pow[x][y]=9;for(int dir=1;dir<=8;dir++){int x1=x+direction[0][dir];int y1=y+direction[1][dir];if(x1>=0&&x1<=7&&y1>=0&&y1<=7&& pow[x1][y1]!=9)pow[x1][y1]--;}}void UnSetWeight(int x,int y){ //位置(x,y)设置为未占用时,修改权值数组for(int dir=1;dir<=8;dir++){ int x1=x+direction[0][dir];struct Element t,data;int pow_min=9;for(int dir=1;dir<=8;dir++){ //探测下一步可走的方向int x1=x+direction[0][dir];int y1=y+direction[1][dir];if(x1>=0&&x1<=7&&y1>=0&&y1<=7&& pow[x1][y1]!=9){if(pow_min>pow[x1][y1])//找出下一步位置中权值最小的{pow_min=pow[x1][y1];t.d=dir; //上一步的方向t.x=x1;t.y=y1;}}}data.x=x; //入栈data.y=y;data.d=t.d;Push(H,data);x=t.x; //坐标更新y=t.y;i++; //步数增加}PLStack H;InitStack(H);Check start;printf("请输入起始坐标x y:");scanf("%d%d",&start.x,&start.y);Step(start,H);Printf(check);return 0;}四.调试分析1.刚开始的时候并没有采用贪心算法,时间复杂度很大,探测量也很大。

数据结构实习报告——国际象棋中马的遍历

数据结构实习报告——国际象棋中马的遍历

数据结构与VC编程实习实习报告学生姓名:学号:专业班级:指导教师:2012年7月14日实习题目在国际象棋棋盘上实现马的遍历一、任务描述及要求国际象棋的棋盘有8×8=64个格子,给它们规定坐标(1,1)到(8,8)。

马在这64个格子的某一个格子上,它的跳动规则是:如果它现在在(x,y)位置,它下一步可以跳到(x±1,y±2)或(x±2,y±1)(所有的“±”之间没有相关性)。

一般来说它下一步可以有八种跳法,但是它不能跳出这64个格子。

设计算法使它不管从哪出发都可以跳遍所有的格子(每个格子只能路过一次)最后回到起点。

1.基本要求:合理设计界面,自行设计国际象棋棋盘,用鼠标选择马的起始位置,起始位置选定后,按“开始”按钮演示马的每一步行走路线。

棋盘和马的显示尽量美观逼真。

功能菜单或按钮自行设计,以合理为目的。

2.扩展要求:对算法进行优化,根据j.c.Warnsdorff规则设计算法,该规则是在所有可跳的方格中,马只可能走这样一个方格:从该方格出发,马能跳的方格数为最少;如果可跳的方格数相等,则从当前位置看,方格序号小的优先。

二、概要设计1.抽象数据类型本次实习中,我主要采用图的深度遍历知识和贪心算法来解决在国际象棋棋盘上实现马的遍历问题。

棋盘上将64个格子视为64个点,将马从一个格子跳到另一个格子视为一条边,则共有168条边,那么可以将棋盘视为一个无向图,马在棋盘上按c.Warnsdorff规则跳动可视为图的深度遍历过程中的一步。

为了实现图的存储,需要建立顶点顺序表和邻接表,这个过程是在图的构造函数里实现的。

图的操作主要包括:给出顶点vertex在表中的位置,给出顶点位置为 v 的第一个邻接顶点的位置,给出顶点v的邻接顶点w的下一个邻接顶点的位置,给出顶点位置为 v 的最优邻接顶点的位置。

图的遍历算法是在视图类里面实现的。

图的抽象数据类型为:ADT Graph{数据:顶点顺序表关系: 邻接表表示了顶点之间的邻接关系操作:①给出顶点vertex在表中的位置②给出顶点位置为 v 的第一个邻接顶点的位置③给出顶点v的邻接顶点w的下一个邻接顶点的位置④给出顶点位置为 v 的最优邻接顶点的位置}由于贪心算法有时不能得到整体最优解,所以我设计了另一种遍历算法。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

马踏棋盘问题
摘要:
马踏棋盘就是在国际象棋8X8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。

理解栈的“后进先出”的特性以及学会使用回溯。

关键字:马踏棋盘、递归、栈、回溯
1.引言
马踏棋盘就是在国际象棋8X8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。

编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2….64依次填入一个8X8的方阵,并输出它的行走路线。

输入:任意一个起始位置;输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线。

2.需求分析
(1)需要输出一个8X8的棋盘,可以采用二维数组的方法实现。

(2)输入马的起始位置,必须保证输入的数字在规定范围内,即0<=X<=7,0<=Y<=7。

(3)保证马能走遍整个棋盘,并且不重复。

(4)在棋盘上输出马的行走路线,标记好数字1、2、3直到64。

3.数据结构设计
采用栈数组为存储结构。

#define maxsize 100
struct
{
int i;
int j;
int director;
}stack[maxsize];
4.算法设计
4.1 马的起始坐标
void location(int x,int y) //马的位置坐标的初始化
{
top++;
stack[top].i=x; //起始位置的横坐标进栈
stack[top].j=y; //起始位置的竖坐标进栈
stack[top].director=-1;
a[x][y]=top+1; //标记棋盘Try(x,y); //探寻的马的行走路线
}
4.2 路径探寻函数
void Try(int i,int j)
{ int count,find,min,director;
int i1,j1,h,k,s;
int
b[8]={-2,-2,-1,1,2,2,1,-1},c[8]={1,-1,-2,-2,-1,1,2,2} ;
//存储马各个出口相对当前位置行、列坐标的增量数组
int b2[8],b1[8];
for(h=0;h<=7;h++)
//用数组b1[8]记录当前位置的下一个位置的可行路径的条数
{ count=0;
i=stack[top].i+c[h];
j=stack[top].j+b[h];
if(i>=0&&i<=7&&j>=0&&j<=7&&a[i][j]==0) //如果找到下一个位置
{
for(k=0;k<=7;k++)
{
i1=i+c[k];
j1=j+b[k];
if(i1>=0&&i1<=7&&j1>=0&&j1<=7&&a[i1]
[j1]==0) //如果找到下一个位置
count++; //记录条数}
b1[h]=count; //将条数存入b1[8]中
}
}
for(h=0;h<=7;h++)
//根据可行路径条数的大小,从小到大排序,并放入数组b2[8]中
{min=9;
for(k=0;k<=7;k++)
if(min>b1[k])
{
min=b1[k];
b2[h]=k;
s=k;
}
b1[s]=9;
}
find=0;
director=stack[top].director;
for(h=director+1;h<=7;h++)//向8个方向进行寻找
{
i=stack[top].i+c[b2[h]];
j=stack[top].j+b[b2[h]];
if(i>=0&&i<=7&&j>=0&&j<=7&&a[i][j]= =0)
{stack[top].director=h; //存储栈的寻找方向
top++; //进栈
stack[top].i=i;
stack[top].j=j;
stack[top].director=-1;//重新初始化下一栈的方向
a[i][j]=top+1;
find=1; //找到下一位置
break;
}
}
if(find!=1)
{a[stack[top].i][stack[top].j]=0; //清除棋盘的标记
top--; //退栈
}
if(top<63)
Try(i,j); //递归
}
4.3输出函数
void display()
{
int i,j;
for(i=0;i<=7;i++)
{ for(j=0;j<=7;j++)
printf("\t%d ",a[i][j]); //输出马的行走路线
printf("\n\n");
}
printf("\n");
}
5.程序实现
5.1 主函数
void main()
{
int i,j,x,y;
for(i=0;i<=7;i++) //棋盘的初始化
for(j=0;j<=7;j++)
a[i][j]=0;
printf("输入X Y (0=<X<=7,0=<Y<=7)\n"); scanf("%d%d",&x,&y);
if(x>=0&&x<=7&&y>=0&&y<=7)
//判断输入的起始位子是否正确
{
location(x,y);
display();
}
else printf("错误\n");
}
5.2运行结果
(1)当输入不符合要求时(2)正确输入时
5.3 算法分析
(1)马的起始坐标
一开始先建立一个栈数组,里面包括横坐标和竖坐标还有方向。

输入马的起始位置,进入坐标起始化函数,让输入的横坐标和竖坐标进栈,并初始化方向,并且标记棋盘,指示此位置已走过,此时的位置是栈的第一个元素,进入路径探寻函数。

(2)路径探寻函数
路径探寻函数中有两个分别存储马各个出口相对当前位置行、列坐标的增量数组。

要使马走遍所有的棋盘,必须要有一定的行走规律。

我使用的是记录当前位置的下一个位置的可行路径的条数,并对它们进行排序,按从小到大的顺序存储在一个一维数组中。

开始进行探寻,分别向8个方向探寻,如果找到一个方向可行,则存储栈的寻找方向,再进栈,重新初始化栈的寻找方向,并用二维数组标记此位置,再使用递归进入下一次新的探寻。

如果在某一次探寻中,没能找到方向,则清除该位置的标记,并退栈,再次递归,回到上次的寻找方向(之前已经存储过栈的寻找方向),跳过已经寻找过的方向,再进行探寻,直到全部棋盘都被走遍。

(3)输出函数
当马走遍所有的棋盘时,输出马的行走路线,因为之前已经把马的行走路线记录在二维数组中了,所以此时只需把二维数组中的标记输出即可。

6.设计体会
本次课程设计让我学会了很多东西,使得我对于栈的理解更深入了,使用更加熟练。

是此之前,我对于回溯并不是特别了解,但是这次设计让我学会了回溯的基本概念以及基础的用法。

当一件事情有很多种方法进行时,我们要将所有的方法集合起来形成一个集合,再用一定的规律去调用这个集合内的方法。

刚开始的时候,我并不能让马走遍所有的棋盘,但当我知道了回溯的思想之后,我修正了我的算法,最终使马走遍所有的棋盘。

我还考虑了递归与非递归的问题,在试验了两种方法之后,发现两种都可以,在时间的复杂度上也没有太大的差别(显示棋盘的时间上),但我还是使用的是递归的方法来完成本次设计。

参考文献:
[1] 严蔚敏、吴伟民编著.数据结构(C语言版).北
京:清华大学出版社,2007
[2] 谭浩强主编.C程序设计(第三版).北京:清华
大学出版,2005
[3] 张蕊、吕涛主编.C程序设计教程. 华中科技大学
出版,2012。

相关文档
最新文档