马踏棋盘分析文档

合集下载

第七次实验 马踏棋盘问题

第七次实验  马踏棋盘问题
桂林电子科技大学
数学与计算科学学院综合性、设计性实验报告
实验室: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:头结点所在的横坐标;

马踏棋盘

马踏棋盘

马踏棋盘学院专业学号学生姓名指导教师年月日摘要:国际象棋想必大家都玩过,但你有没有想过,让一个“马”遍历国际象棋8*8的棋盘,有没有可能?如果有可能,在给定起点的情况下,有多少种可能?下面,我们将用计算机来模拟“马”对棋盘的遍历.关键字:回溯算法贪心算法遍历正文:已知国际象棋为8×8棋盘,共64个格,规则中,马按照如图所示规则移动。

将马放在任意方格中,令马遍历每个方格一次且仅一次,编制非递归程序,将数字1,2, (64)照马的行走路线依次填入一个8×8的方阵,并输出结果。

通过结合图示,我们不难发现,当马的起始位置(i,j)确定的时候,可以走到下列8个位置之一:(i-2,j+1)、(i-1,j+2)、(i+1,j+2)、(i+2,j+1)、(i+2,j-1)、(i+1,j-2)、(i-1,j-2)、(i-2,j-1)但是,如果(i,j)靠近棋盘的边缘,上述有些位置可能超出棋盘范围,成为不可达的位置。

8个可能位置可以用一维数组Htry1[0…7]和HTry2[0..7]来表示:Htry1:0 1 2 3 4 5 6 7-2 -1 1 2 2 1 -1 -2 Htry2:0 1 2 3 4 5 6 71 2 2 1 -1 -2 -2 -1所以位于(i,j)的马可以走到新位置是在棋盘范围内的(i+ Htry1[h],j+Htry2[h]),其中h的取值是0~7.整个问题,我们可以用两种算法来解决,既“回溯算法”与“贪心算法”我们先来看回溯算法:搜索空间是整个棋盘上的8*8个点.约束条件是不出边界且每个点只能经过一次.搜索过程是从一点(i,j)出发,按深度有限的原则,从8个方向中尝试一个可以走的点,直到走过棋盘上所有的点.当没有点可达且没有遍历完棋盘时,就要撤销该点,从该点上一点开始找出另外的一个可达点,直到遍历完整个棋盘我们接着看程序的需求分析:1.输入的形式和输入值的范围;分开输入马的初始行坐标X和列坐标Y,X和Y的范围都是[0,7]。

C++ 数据结构课程设计 马踏棋局文档

C++ 数据结构课程设计 马踏棋局文档

课程设计题目1 问题描述将马随机放在国际象棋的8*8棋盘Board[8][8]的某个方格中,马按走棋规则进行移动,要求每个方格上只进入一次,走遍棋盘上全部64个方格2 基本要求(1)采用图形界面实现该游戏。

(2)从键盘输入马的初始位置。

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

3系统分析与设计3.1 数据结构逻辑结构为线性结构,用顺序栈。

坐标点用已结构体来表示,并将其的位置放在s[step]的栈中,而且将每走一步的坐标放在另一栈s1中3.2 算法设计1.程序框架及功能模块划分:2.设计功能的分析与实现void exit(point p)参数:point功能:计算出下一步可能位置,按其各个位置下一个位置的和压栈到s[]中算法描述:接受参数传来的值,按次序加上int horizontal[]={2,1,-1,-2,-2,-1,1,2};int vertical[]={-1,-2,-2,-1,1,2,2,1};再根据legal函数来判断是否合法(x(0~7),y(0~7))是,则保存在point ap[]中,再按各自下一步的数目从大到小排序。

最后,将ap[]中的点压栈。

int number(point p)参数:point功能:找出当前位置下一步的各种可能位置,计算可能之和算法描述:接受参数传来的值,按次序加上int horizontal[]={2,1,-1,-2,-2,-1,1,2};int vertical[]={-1,-2,-2,-1,1,2,2,1};再根据legal函数来判断是否合法(x(0~7),y(0~7))是,则加1并将值返回void next(point p)参数:point功能:/找出各个位置并将其步数记录算法描述:将其步数记录在board[][]的相应位置,并将这点压栈到s1,判断步数是否小于64,再根据这四个条件选择执行其中的一个,再递归调用next.bool legal(point p)参数:point功能:判断是否可行,合法(是否在棋盘上,是否走过)算法描述:用这样的语句if((p.x>=0)&&(p.x<n)&&(p.y<n)&&(p.y>=0)&&(bo ard[p.x][p.y]==0))return true;elsereturn false;4 测试数据及结果测试数据和运行输出及结果分析输入x(0-7),y(0-7)0 01 34 3 18 49 32 13 164 19 56 33 14 17 50 3157 2 35 48 55 52 15 1220 5 60 53 36 47 30 5141 58 37 46 61 54 11 266 21 42 59 38 27 64 2943 40 23 8 45 62 25 1022 7 44 39 24 9 28 63 Press any key to continue输入x(0-7),y(0-7)0 9输入不合法,重输入!输入x(0-7!),y(0-7!)4 530 27 10 49 40 25 8 511 48 29 26 9 6 39 2428 31 56 45 50 41 4 747 12 51 42 19 44 23 3832 57 46 55 52 1 18 313 64 53 60 43 20 37 2258 33 62 15 54 35 2 1763 14 59 34 61 16 21 36 Press any key to continue5 总结调试过程中遇到的主要问题,是如何解决的;问题1:只走到63步原因:第64步就走完了,并且s[62]中只有一个元素,这个判断条件(s[step].base==s[step].top&&number(p2)==0)满足就进入了,而始终不能走完解决方法:改了判断条件,改为((s[step].base==s[step].top&&number(p2)==0)&&step!=n* n-1)解决方案:用InitStack(s1)初始化问题3:冒泡排序超出边界原因:循环次数大解决方案:减少循环次数看了其他同学,都差不多,我已经按马的下一位置最难的先走,再走难度次之的位置。

马踏棋盘的实习报告

马踏棋盘的实习报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

马踏棋盘

马踏棋盘

课程设计报告-马踏棋盘题目:编制一个演示国际象棋中马踏棋盘的程序.一、需求分析1.问题描述:本程序中,将马随机放在国际象棋的8×8棋盘Board[8][8]的某个方格中,马按走棋规则进行移动。

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

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

2. 程序功能:在计算机终端上显示"1指定位置;2随机;"两种选择方案.由用户在键盘上输入1,2,使计算机执行对应方案:将数字1,2, (64)次填入一个8×8的方阵,输出方格。

3. 测试数据(1)确定入口位置,判断x,y是否在1到8的范围内;(2)确定b[9],判断最小出口;二、概要设计为实现上述程序功能,应建立一个栈和两个数组。

为此,需要两个抽象数据类型:栈,数组。

1.栈的抽象数据类型定义为:ADT stack {数据对象:D={a i|a i∈ElemSet,i=1,2,...,n, n≥ 0}数据关系:Rl={<a i-1,a i>|a i-1,a i∈D,a i-1<a i, a i∈D, i=2,...,n} 约定a n 端为栈顶,a1端为栈底。

基本操作:InitStack(&S)操作结果:构造一个空栈S。

DestoryStack(&S)初始条件:栈S已存在。

操作结果:栈S被销毁。

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

操作结果:将S清空为空栈。

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

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

StackLength(S)初始条件:栈S已存在。

操作结果:返回S的元素个数,即栈的长度。

GetTop(S,&e)初始条件:栈S已存在且非空。

操作结果:用e返回S的栈顶元素。

Push(&S,e)初始条件:栈S已存在。

马踏棋盘的实习报告

马踏棋盘的实习报告

马踏棋盘实习报告题目:设计一个国际象棋的马踏遍棋盘的演示程序班级:姓名:学号:完成日期:一.需求分析将马随机放在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.刚开始的时候并没有采用贪心算法,时间复杂度很大,探测量也很大。

棋盘算法实验报告(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)马的起始坐标一开始先建立一个栈数组,里面包括横坐标和竖坐标还有方向。

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

数据结构课程设计题目:马踏棋盘院系:班级:学号:姓名:2014-2015年度第1学期马踏棋盘一.题目:马踏棋盘 (3)二. 设计目标 (3)三. 问题描述 (3)四. 需求分析 (4)五. 概要设计 (4)第一步:定义四个常量和一个数据类型 (4)第二步:构造函数 (4)六. 详细设计(给出算法的伪码描述和流程图) (5)流程图设计 (5)代码分析 (9)第一步:定义常量与变量 (9)第二步:构造函数 (9)●定义一个结构体类型 (9)●创建一个初始化函数 (10)●创建提示输入函数 (10)●创建产生新节点函数 (11)●创建计算路径函数 (12)●创建入栈函数 (13)●创建出栈函数 (13)●创建输出函数 (13)第三步:在主函数中调用其它函数 (15)七. 测试分析 (16)八. 使用说明 (16)九. 测试数据 (16)十.课程设计总结 (17)一.题目:马踏棋盘二. 设计目标帮助学生熟练掌握顺序栈的基本操作,让学生深入了解栈的使用,使得更深层次的灵活运用栈。

三. 问题描述○所谓的马踏棋盘是:将马随机放在国际象棋的8×8棋盘的某个方格中,马按走棋规则(马走日字)进行移动。

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

由用户自行指定一个马的初始位置,求出马的行走路线,并按照求出的行走路线的顺序,将数字1、2、…、64依次填入一个8X8的方阵并输出。

从用户给出的初始位置开始判断,按照顺时针顺序,每次产生一个新的路点,并验证此路点的可用性,需要考虑的是当前路点是否超出棋盘范围和此路点是否已经走过。

如果新路点可用,则入栈,并执行下一步,重复进行如上步骤,每次按照已走路点的位置生成新路点。

如果一个路点的可扩展路数为0,进行回溯,直到找到一个马能踏遍棋盘的行走路线并输出。

四. 需求分析1. 让用户输入马的初始位置;2. 按照马的行走路线,判断马是否能够走遍整个棋盘;3. 输出结果(若能走遍,则输出马的行走路线,若不能,提示用户“此时不能踏遍棋盘上所有点!”)五. 概要设计为了实现上述程序功能,程序包含以下几大模块:第一步:定义四个常量和一个数据类型:MAXNUM、INVALIDDIR、MAXLEN、MAXDIR、HorsePoint 第二步:构造函数:void Initial() //初始化函数;void PushStack(HorsePoint positon) //入栈函数;HorsePoint GetInitPoint() //请求用户输入函数;HorsePoint GetNewPoint(HorsePoint *parent) //产生新节点函数;void CalcPoint(HorsePoint hh) //计算路径的函数;void PrintChess() //输出函数;int main(int argc,char* argv[]) //主函数六. 详细设计(给出算法的伪码描述和流程图)总体操作步骤如下:流程图设计:代码分析:第一步:定义常量与变量:常量:MAXNUM 8 ---------- /*横纵格数的最大值*/INVALIDDIR -1 ---------- /*无路可走的情况*/MAXLEN 64 ---------- /*棋盘总个数*/MAXDIR 8 ---------- /*下一步可走的方向*/ 变量:HorsePoint ChessPath[MAXLEN] /*模拟路径栈*/Int count /*入栈节点个数*/int ChessBoard[MAXNUM][MAXNUM] /*标志棋盘数组*/ 第二步:构造函数:为了明确马将要走的路线,我们必须定义一个结构体类型:typedef struct{int x; /*表示横坐标*/int y; /*表示纵坐标*/int direction; /*表示移动方向*/ }HorsePoint;●创建一个初始化函数:void Initial() /{int i,j;for(i=0;i<MAXNUM;i++)for(j=0;j<MAXNUM;j++)ChessBoard[i][j]=0; /*棋盘格均初始化为0,代表没走过*/for(i=0;i<MAXLEN;i++){ChessPath[i].x=0;ChessPath[i].y=0;ChessPath[i].direction=INVALIDDIR;}count=0; /*栈中最初没有元素*/}●创建提示输入函数HorsePoint GetInitPoint(){HorsePoint positon;do{printf("\n请输入起始点(y,x):");scanf("%d,%d",&positon.x,&positon.y);printf("\n请稍等......\n");printf("\n\n");}while(positon.x>=MAXNUM || positon.y>=MAXNUM || positon.x<0 || positon.y<0); /*不超过各个边缘时*/positon.direction=INVALIDDIR; /*是初值,没走过*/return positon;}创建产生新节点函数:HorsePoint GetNewPoint(HorsePoint *parent){int i;HorsePoint newpoint;/*能走的8个方向的坐标增量*/int tryx[MAXDIR]={ 1, 2, 2, 1,-1,-2,-2,-1};int tryy[MAXDIR]={-2,-1, 1, 2, 2, 1,-1,-2};/*新结点可走方向初始化*/newpoint.direction=INVALIDDIR;parent->direction=parent->direction++; /*上一结点能走的方向*/for(i=parent->direction;i<MAXDIR;i++){newpoint.x=parent->x+tryx[i]; /*试探新结点的可走方向*/newpoint.y=parent->y+tryy[i];if(newpoint.x<MAXNUM&&newpoint.x>=0&&newpoint.y<MAXNUM&&newpoint.y>=0 &&ChessBoard[newpoint.x][newpoint.y]==0){parent->direction=i; /*上一结点可走的方向*/ChessBoard[newpoint.x][newpoint.y]=1; /*标记已走过*/return newpoint;}}parent->direction=INVALIDDIR;return newpoint;}创建计算路径函数:void CalcPoint(HorsePoint hh){HorsePoint npositon;HorsePoint *ppositon;Initial(); /*调用初始化函数*/ppositon=&hh; /*调用输入起始点函数*/PushStack(*ppositon);while(!(count==0 || count==MAXLEN))/*当路径栈不空或不满时*/{ppositon=&ChessPath[count-1]; /*指针指向栈*/npositon=GetNewPoint(ppositon); /*产生新结点*/if(ppositon->direction!=INVALIDDIR) /*如果可以往下走*/{ChessPath[count-1].direction=ppositon->direction;PushStack(npositon);}elsePopStack();}}●创建入栈函数:void PushStack(HorsePoint positon) /*入栈函数*/{ChessBoard[positon.x][positon.y]=1; /*把标志设为1,证明已走过*/ChessPath[count]=positon; /*把标志为1的结点入栈*/count++; /*栈中结点个数加1*/}●创建出栈函数:HorsePoint PopStack() /*出栈函数*/{HorsePoint positon;count--;positon=ChessPath[count];ChessBoard[positon.x][positon.y]=0;ChessPath[count].direction=INVALIDDIR;return positon;}●创建输出函数:void PrintChess() /*以8*8矩阵的形式输出运行结果*/{int i,j;/*state[i][j]为棋盘上(i,j)点被踏过的次序*/int state[MAXNUM][MAXNUM];int step=0; /*行走步数初始化*/HorsePoint positon;count=MAXLEN;if(count==MAXLEN) /*当棋盘全部走过时*/{for( i=0;i<MAXLEN;i++){step++;positon=ChessPath[i];state[positon.x][positon.y]=step;}for(i=0;i<MAXNUM;i++){printf("\t\t");for( j=0;j<MAXNUM;j++){if(state[i][j]<10)printf(" ");printf("%d ",state[i][j]); /*按顺序输出马踏过的点*/}printf("\n");}printf("\n");}elseprintf("\t\t此时不能踏遍棋盘上所有点!\n");}第三步:在主函数中调用其它函数int main(int argc,char* argv[]){HorsePoint h; /*定义一个结构体类型的变量*/h=GetInitPoint(); /*将用户输入的数据赋给变量h*//*先调用初始化函数,然后将用户输入的数据入栈,判断马的行走方向,确定后,产生新节点,将新节点入栈,直到马踏遍整个棋盘或者无法踏遍整个棋盘为止。

相关文档
最新文档