实验报告 马踏棋盘
数据结构 马踏棋盘 设计报告
![数据结构 马踏棋盘 设计报告](https://img.taocdn.com/s3/m/31022a360912a2161479296b.png)
《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目:姓名:院系:专业:年级:学号:指导教师: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循环,取出符合条件的栈顶元素。
利用函数,找出栈顶元素周围未被占用的新位置,如果有,新位置入栈;否则弹出栈顶元素。
马踏棋盘
![马踏棋盘](https://img.taocdn.com/s3/m/1e26f08b84868762caaed566.png)
国际象棋的棋盘为8*8的方格棋盘。
现将"马"放在任意指定的方格中,按照"马"走棋的规则将"马"进行移动。
要求每个方格只能进入一次,最终使得"马"走遍棋盘的64个方格。
编写一个C程序,实现马踏棋盘操作,要求用1~64这64个数字标注马移动的路径,也就是按照求出的行走路线,将数字1,2,……64依次填入棋盘的方格中,并输出。
国际象棋中,"马"的移动规则如图9-4所示。
图9-4 "马"的移动规则如图9-4所示,图中实心的圆圈代表"马"的位置,它下一步可移动到图中空心圆圈标注的8个位置上,该规则叫做"马走日"。
但是如果"马"位于棋盘的边界附近,它下一步可移动到的位置就不一定有8个了,因为要保证"马"每一步都走在棋盘中。
【题目分析】马踏棋盘的问题其实就是要将1,2,…,64填入到一个8*8的矩阵中,要求相邻的两个数按照"马"的移动规则放置在矩阵中。
例如数字a放置在矩阵的(i,j)位置上,数字a+1只能放置在矩阵的(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)之中的一个位置上。
将矩阵填满并输出。
这样在矩阵中从1,2…遍历到64,就得到了马踏棋盘的行走路线。
因此本题的最终目的是输出一个8*8的矩阵,在该矩阵中填有1,2…64这64个数字,相邻数字之间遵照"马走日"的规则。
解决马踏棋盘问题的一种比较容易理解的方法是应用递归的深度优先搜索的思想。
因为"马"每走一步都是盲目的,它并不能判断当前的走步一定正确,而只能保证当前这步是可走的。
"马"走的每一步棋都是从它当前位置出发,向下一步的8个位置中的1个行走(在它下一步有8个位置可走的情况下)。
马踏棋盘
![马踏棋盘](https://img.taocdn.com/s3/m/2642ec020740be1e650e9a41.png)
马踏棋盘学院专业学号学生姓名指导教师年月日摘要:国际象棋想必大家都玩过,但你有没有想过,让一个“马”遍历国际象棋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]。
马踏棋盘的实习报告
![马踏棋盘的实习报告](https://img.taocdn.com/s3/m/6fe0f75e6fdb6f1aff00bed5b9f3f90f77c64d4f.png)
马踏棋盘的实习报告实习报告:马踏棋盘一、实习单位及实习岗位简介实习单位:ABC软件公司实习岗位:算法工程师助理二、实习内容和任务作为算法工程师助理,我的主要任务是协助开发团队完成一个名为“马踏棋盘”的小游戏的设计和实现。
该游戏是基于棋盘上的骑士的移动规则进行设计的。
具体任务及完成情况如下:1.学习和理解“马踏棋盘”游戏的规则。
在开始设计游戏之前,首先需要深入了解和理解“马踏棋盘”的规则。
通过查阅相关资料和与开发团队成员的讨论,我对游戏规则有了初步的认识和理解。
2.设计游戏的棋盘和角色。
根据游戏规则的要求,我与开发团队成员一起设计和绘制了游戏的棋盘和角色。
棋盘采用8*8的方格,并且在其中的随机位置放置了一些障碍物,增加游戏的难度和挑战性。
角色则是一个具有代表骑士的形象的图标。
3.实现骑士的移动和规则判断。
在游戏中,骑士可以根据特定的移动规则在棋盘上移动。
根据游戏规则的要求,我编写了相应的算法,实现了骑士的移动和规则判断的功能。
通过这个功能,用户可以通过点击棋盘上的方格,移动骑士来完成游戏的目标。
4.添加游戏的界面和交互。
除了基本的游戏功能以外,我们还为游戏设计了用户友好的界面和交互。
通过游戏界面,用户可以清楚地看到棋盘和角色的位置,并且可以通过点击方格或者使用方向键来控制骑士的移动。
同时,我们还添加了计时器和得分系统,提升了游戏的趣味性和挑战性。
5.进行游戏的测试和优化。
为了确保游戏的稳定性和良好的体验效果,我们进行了多轮的测试和优化。
通过不断地发现和修复bug,我们最终完成了一个可以正常运行、界面友好、操作流畅的游戏。
三、实习收获和体会在这次实习中,我通过与开发团队的合作,深入了解了算法在游戏开发中的应用。
通过参与“马踏棋盘”游戏的设计和实现,我不仅加深了对算法和数据结构的理解,在实践中熟悉了常用的算法编程技巧,还提升了团队协作和解决问题的能力。
通过这次实习,我深刻体会到了算法在实际项目中的重要性和应用价值。
数据结构实验报告马踏棋盘
![数据结构实验报告马踏棋盘](https://img.taocdn.com/s3/m/b9352d7ddd3383c4ba4cd22e.png)
目录1 课程设计的目的 (x)2 需求分析 (x)3 课程设计报告内容 (x)1、概要设计 (x)2、详细设计 (x)3、调试分析 (x)4、用户手册 (x)5、测试结果 (x)6、程序清单 (x)4 小结 (x)5 参考文献 (x)2011年5月23日1、课程设计的目的(1)熟练使用栈和队列解决实际问题;(2)了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;(3)初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;(4)提高综合运用所学的理论知识和方法独立分析和解决问题的能力;2、需求分析*问题描述:将马随机放在国际象棋的8X8棋盘Bo阿rd[0..7,0..7]的某个方格中,马按走棋规则进行移动。
要求每个方格上只进入一次,走遍棋盘上全部64个方格。
编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入8X8的方阵输出之。
*测试数据:由读者指定,可自行指定一个马的初始位置。
*实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。
并探讨每次选择位置的“最佳策略”,以减少回溯的次数。
3、课程设计报告内容根据分析先建了2个结构体struct PosType //马的坐标位置类型{int m_row; //行值int m_col; //列值};struct DataType //栈的元素类型{PosType seat; //马在棋盘中的“坐标位置”int di; //换方向的次数};chess::chess()bool chess::chessPath(PosType start) //在棋盘中进行试探寻找下一步位置并同时记录位置,以及涉及到的入栈出栈void chess::Print() //打印马走的路径PosType chess::NextPos(PosType a,int di)//根据当前点的位置a和移动方向di,试探下一位置4、总结一、这次课程设计的心得体会通过实践我的收获如下:1、巩固和加深了对数据结构的理解,提高综合运用本课程所学知识的能力。
马踏棋盘实习报告
![马踏棋盘实习报告](https://img.taocdn.com/s3/m/7ef7eafdb1717fd5360cba1aa8114431b90d8e37.png)
一、实习背景马踏棋盘问题是一个经典的算法问题,也是数据结构课程中的一个重要实验。
通过对马踏棋盘问题的研究和实现,可以加深对栈和队列这两种抽象数据类型的理解,提高算法设计能力和编程能力。
本次实习旨在通过编程实现马踏棋盘问题,并分析其算法的复杂度和优化策略。
二、实习目的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)在遍历过程中,避免重复访问已经访问过的位置。
马踏棋盘的实习报告
![马踏棋盘的实习报告](https://img.taocdn.com/s3/m/a41ac502e518964bce847c4d.png)
马踏棋盘实习报告题目:设计一个国际象棋的马踏遍棋盘的演示程序班级:姓名:学号:完成日期:一.需求分析将马随机放在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篇)](https://img.taocdn.com/s3/m/11d59fdd1b37f111f18583d049649b6649d7094c.png)
个人自我介绍简单大方
很抱歉,但我无法为您提供____字的自我介绍。
以下是一个简洁而大方的自我介绍示例,供您参考:
大家好,我叫[姓名]。
很高兴有机会向大家介绍一下自己。
我出生并长大在[所在地],是一个勤奋、积极向上的人。
在学业方面,我于[毕业时间]从[学校名称]获得了[学位/专业]学位。
在大学期间,我通过自我努力和课外学习,取得了良好的学术成绩,并参与了一些学生组织和社团活动。
这些经历不仅培养了我的团队合作和领导能力,也加强了我的沟通和组织能力。
在工作方面,我有[工作年限]年的相关工作经验。
我曾在[公司/组织名称]担任[职位],负责[工作职责]。
在这期间,我不断努力提升自己的专业知识和技能,以适应快速发展的工作环境。
我善于分析问题并找出解决方案,能够有效地与团队合作并承担责任,这些都为我赢得了同事和上级的认可。
除了工作,我也积极参与志愿者活动,希望能为社区和弱势群体做一点贡献。
我相信,通过奉献和关心他人,我们可以建立一个更加和谐和温暖的社会。
在个人生活中,我喜欢阅读、旅行和运动。
阅读扩展了我的视野,旅行让我能够体验不同的文化和风景,而运动则让我保持健康和积极的精神状态。
此外,我也很喜欢与家人和朋友相处,分享彼此的喜怒哀乐。
总的来说,我是一个热情、乐观、有责任心的人。
我相信勤奋和坚持可以取得成功,而真诚和善良可以赢得他人的信任和支持。
我希望能够在您的团队中发挥我的才能,并与大家一同成长和进步。
这就是我简单的自我介绍,谢谢大家!。
马踏棋盘 数据结构实践报告
![马踏棋盘 数据结构实践报告](https://img.taocdn.com/s3/m/5e31ff3b67ec102de2bd8979.png)
马踏棋盘问题摘要:马踏棋盘就是在国际象棋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)马的起始坐标一开始先建立一个栈数组,里面包括横坐标和竖坐标还有方向。
数据结构课程设计 马踏棋盘分解
![数据结构课程设计 马踏棋盘分解](https://img.taocdn.com/s3/m/6ea945b727d3240c8547efaa.png)
杭州师范大学钱江学院课程设计2013 年12 月21 日目录一.概述 (3)二.总体方案设计 (3)三.详细设计 (4)四.最终输出 (6)五.课程设计总结 (10)参考文献 (13)一概述1.课程设计的目的(1)课题描述设计一个国际象棋的马踏遍棋盘的演示程序。
(2)课题意义通过“马踏棋盘”算法的研究,强化了个人对“栈”数据结构的定义和运用,同时也锻炼了自身的C语言编程能力。
另一方面,通过对“马踏棋盘” 算法的研究,个人对“迷宫”、“棋盘遍历”一类的问题,有了深刻的认识,为今后解决以此问题为基础的相关的问题,打下了坚实的基础。
(3)解决问题的关键点说明解决问题的关键首先要熟练掌握 C语言编程技术,同时能够熟练运用“栈”数据结构。
另外,态度也是非常重要的。
在课程设计过程中,难免会遇到困难,但是不能轻易放弃,要肯花时间,能静得下心,积极查阅相关资料,积极与指导老师沟通。
2.课程设计的要求(1)课题设计要求将马随机放在国际象棋的8X 8棋盘Board[0〜7][0〜7]的某个方格中,马按走棋规则进行移动。
要求每个方格只进入一次,走遍棋盘上全部64个方格。
编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8X 8的方阵,输出之。
程序由回溯法和贪心法实现,比较两种算法的时间复杂度。
(2)课题设计的思路首先,搞清楚马每次在棋盘上有 8个方向可走,定义两个一位数组,来存储马下一着点的水平和纵向偏移量。
程序再定义一个8*8二维数组,初始所有元素置0,起始点元素置1。
若为回溯法,初始方向数据(一维数组下标) 入栈。
随后,马从起始点开始,每次首先寻找下一可行的着点,然后记下方向,方向数据入栈,把该位置元素置为合适的序列号,若无下一可行着点,则回溯,寻找下一方向位置着点,以此类推,直到 64填入数组中,则输出二维数组,即为马可走的方案。
若为贪婪法,选择下一出口的贪婪标准是在那些允许走的位置中,选择出口最少的那个位置。
马踏棋盘算法
![马踏棋盘算法](https://img.taocdn.com/s3/m/5ef46ae418e8b8f67c1cfad6195f312b3169ebd3.png)
马踏棋盘算法介绍1.马踏棋盘算法,也称骑⼠周游问题2.规则:将马随机放在国际象棋的 8×8 棋盘[0~7][0~7]的某个⽅格中,马按⾛棋规则(马⾛⽇字)进⾏移动,要求每个⽅格只进⼊⼀次,⾛遍棋盘上全部 64 个⽅格3.基本思想:图的深度优先搜索 + 贪⼼算法(优化)步骤1.创建⼀个⼆维数组代表棋盘2.将当前位置设置为已经访问,把当前马在棋盘的位置标记为第⼏步(step),然后根据当前位置,计算马还能⾛哪些位置,并放⼊ArrayList,最多有8个位置3.获取到ArrayList后,⽤贪⼼算法优化4.遍历ArrayList中存放的所有位置,判断哪个位置可以⾛通,如果⾛通,就继续,⾛不通,就回溯5.判断是否⾛完整个棋盘,使⽤step和应该⾛的步数⽐较,如果没有达到数量,则表⽰没有完成任务,并将整个棋盘置0贪⼼算法优化ArrayList1.基本思想:根据当前这个⼀步的所有的下⼀步的选择位置,进⾏⾮递减(即不严格递增)排序,减少回溯的次数步骤(1)传⼊Comparotor,重写ArrayList的sort⽅法(2)获取ArrayList所有位置的通路个数,按⾮递减排序(3)即当前位置的下⼀步的下⼀步通路最少,就优先选择代码实现import java.awt.*;import java.util.ArrayList;import java.util.Arrays;import parator;public class KnightTravel {//骑⼠周游问题public int row;//棋盘的⾏数public int column;//棋盘的列数public int[][] chessboard;//棋盘public boolean[][] visited;//标记棋盘的各个位置是否被访问过,true:已访问public boolean finished;//标记是否棋盘的所有位置都被访问,若为true,表⽰算法计算成功public int step = 1;//初始为第⼀步public static void main(String[] args) {KnightTravel knight = new KnightTravel(8, 8);long start = System.currentTimeMillis();knight.travel(knight.chessboard, 0, 0, knight.step);long end = System.currentTimeMillis();System.out.println("共耗时: " + (end - start) + " 毫秒");knight.result();}public KnightTravel(int row, int column) {this.row = row;this.column = column;this.chessboard = new int[row][column];this.visited = new boolean[row][column];}public void result() {//打印算法结果for (int[] row : chessboard) {System.out.println(Arrays.toString(row));}}//马踏棋盘算法//chessboard:棋盘,row:马⼉当前的位置的⾏,从0开始,column:马⼉当前的位置的列,从0开始,step:第⼏步,初始位置是第1步 public void travel(int[][] chessboard, int row, int column, int step) {chessboard[row][column] = step;visited[row][column] = true; //标记该位置已经访问//获取当前位置可以⾛的下⼀个位置的集合ArrayList<Point> access = next(new Point(column, row));sort(access);//对access进⾏⾮递减排序while (!access.isEmpty()) {Point next = access.remove(0);//取出下⼀个可以⾛的位置if (!visited[next.y][next.x]) {//判断该点是否已经访问过travel(chessboard, next.y, next.x, step + 1);}}if (step < this.row * this.column && !finished) {//⽆路可⾛且未⾛完,就回溯到上⼀位置chessboard[row][column] = 0;visited[row][column] = false;} else {//成功⾛完时,finished是防⽌回溯时将最优解覆盖掉finished = true;}}//根据当前位置(curPoint),计算马还能⾛哪些位置(point),并放⼊⼀个集合中(ArrayList), 最多有8个位置public ArrayList<Point> next(Point curPoint) {//储存马在当前位置的通路ArrayList<Point> access = new ArrayList<>();//Point对象中,属性x代表列,属性y代表⾏Point point = new Point();//以下操作,判断马的8个⽅向是否可⾏,并记录通路位置,但不记录该位置是否已访问if ((point.x = curPoint.x - 2) >= 0 && (point.y = curPoint.y - 1) >= 0) {access.add(new Point(point));}if ((point.x = curPoint.x - 1) >= 0 && (point.y = curPoint.y - 2) >= 0) {access.add(new Point(point));}if ((point.x = curPoint.x + 1) < column && (point.y = curPoint.y - 2) >= 0) {access.add(new Point(point));}if ((point.x = curPoint.x + 2) < column && (point.y = curPoint.y - 1) >= 0) {access.add(new Point(point));}if ((point.x = curPoint.x + 2) < column && (point.y = curPoint.y + 1) < row) {access.add(new Point(point));}if ((point.x = curPoint.x + 1) < column && (point.y = curPoint.y + 2) < row) {access.add(new Point(point));}if ((point.x = curPoint.x - 1) >= 0 && (point.y = curPoint.y + 2) < row) {access.add(new Point(point));}if ((point.x = curPoint.x - 2) >= 0 && (point.y = curPoint.y + 1) < row) {access.add(new Point(point));}return access;}//根据当前这个⼀步的所有的下⼀步的选择位置,进⾏⾮递减(不严格递增)排序, 减少回溯的次数public void sort(ArrayList<Point> access) {access.sort(new Comparator<Point>() {@Overridepublic int compare(Point o1, Point o2) {int count1 = next(o1).size();int count2 = next(o2).size();if (count1 < count2) {return -1;} else if (count1 == count2) {return 0;} else {return 1;}}});}}。
马踏棋盘课程设计实验报告
![马踏棋盘课程设计实验报告](https://img.taocdn.com/s3/m/6dab35f40722192e4436f695.png)
马踏棋盘课程设计实验报告《数据结构》课程设计实验报告课程名称: 《数据结构》课程设计课程设计题目: 马踏棋盘姓名: 邱可昉院系: 计算机学院专业: 计算机科学与技术班级: 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的方阵输出之。
*测试数据:由读者指定,可自行指定一个马的初始位置。
*实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。
并探讨每次选择位置的“最佳策略”,以减少回溯的次数。
数据结构课程设计(马踏棋盘)
![数据结构课程设计(马踏棋盘)](https://img.taocdn.com/s3/m/805ed311af45b307e8719762.png)
中南民族大学数据结构课程设计报告姓名:康宇年级: 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];用来标记棋盘。
数据结构课程设计实习报告-马踏棋盘
![数据结构课程设计实习报告-马踏棋盘](https://img.taocdn.com/s3/m/cd950595312b3169a551a408.png)
数据结构课程设计实习报告题目:马踏棋盘(实习题 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.。
马踏棋盘——一个数据结构综合实验案例新解
![马踏棋盘——一个数据结构综合实验案例新解](https://img.taocdn.com/s3/m/2130b24b336c1eb91a375d49.png)
总第 1 4卷 1 7期 5 21 0 2年 9月
大 众 科 技
P uar in e & Te h oo y op l e c Sc c n lg
Vo . 4 N0 9 L1 .
Se t pemb r 2 1 e 0 2
马踏 棋 盘
一 个 数 据 结构 综 合 实验 案 例 新解
知从 何 下 手 ,产 生 畏 难 心 理 ,会 打 击 学 生解 决 问题 的 自信 心 ;
而 案 例 过 于 简 单 , 则 达 不 到 综 合 实验 要 求 ,起 不 到锻 炼 学 生 的 目的 。一 个 合 适 的 综 合 实 验 案 例 ,应 该具 有 以 下几 个 特 点 :
课程打 下坚 实的基础 。然而 , 数据 结构也是一门理论性很强 的课程 ,理论 知识抽象 、概 念多 、算法 多而杂 ,学 生不好理 解 ,设 计程序无 从下手 。很 多学生反 映这 门课 “ 难懂 、不好 用 ”。学生不通 过实践很难对其 理论有深入 理解和应用 。因
Ab t a t I h sp p r t ep o lm f o s r v l g o h s b ad wa n r d c d i t a a s u t r x e me t e c i g a n s r c : n t i a e , h r b e o r eta ei n c e s o r si to u e n o d t t c u ee p r h n r i n a h n sa t
马踏棋盘的实习报告
![马踏棋盘的实习报告](https://img.taocdn.com/s3/m/a41ac502e518964bce847c4d.png)
马踏棋盘实习报告题目:设计一个国际象棋的马踏遍棋盘的演示程序班级:姓名:学号:完成日期:一.需求分析将马随机放在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.刚开始的时候并没有采用贪心算法,时间复杂度很大,探测量也很大。
1实验题目马踏棋盘
![1实验题目马踏棋盘](https://img.taocdn.com/s3/m/07e4c10543323968011c9243.png)
1:实验题目:马踏棋盘,2:实验目的:队列和栈的操作练习:3:实验具体内容:设计一个国际象棋的马踏遍棋盘的演示程序。
将马随机放在国际象棋8x8棋盘Board[8][8]的某个方格中,马按走棋规则进行移动。
要求每个方格只进入一次,走遍棋盘上全部64个方格。
编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8x8的方阵,输出之。
矚慫润厲钐瘗睞枥庑赖賃軔。
4:数据结构算法思想:数据结构:简单的结构体和相关数组;算法思想:a :首先定义一个8*8的数组用于存放马的跳步过程;定义方向结点;b :获得马的第一个踩入点,调用findway()函数,该函数的while()语句将获得下一个要踩入的结点坐标,该过程调用pathnum()函数(注解:该函数给出了可踩入的所有结点各自的路径数目); 在findway()中,选择的要进入的下一个结点就是在pathway()中找到的结点(注解:该结点是可跳入的所有结的中路径最少的一个);聞創沟燴鐺險爱氇谴净祸測。
c : 在每步踩入前,将该结点的下标和踩入的次序做记录并输出;d : 读取最后一个结点的相关信息;5:模块划分:6:详细设计及运行结果:A:定义一个8*8的数组,用于存放每次踩入的结点位置;B:获取第一个踩入点;C:调用findway()函数Findway() 函数功能介绍:定义一个结点类型数组,用于存放8个下一步可踩入结点的信息;期间调用pathnum() 函数,该函数功能是记录所有下一个可踩入结点的可执行路径数目);选择下一个结点中路径最少的结点为下一个踩入的结点;在进入下一个踩入点前,先保存该结点的信息并输出,然后依次寻找下一个结点;残骛楼諍锩瀨濟溆塹籟婭骒。
D:寻找最后一个结点,并赋给相应信息;运行结果如下:7:调试情况,设计技巧和相关方法:A : 该开始想着利用栈的数据结构,记录回溯的相关信息,后来查资料发现如果每次入结点路径最少的那个结点,根本不会产生回溯的过程,后来就省去了栈队列的应用;酽锕极額閉镇桧猪訣锥顧荭。
第七次实验 马踏棋盘问题
![第七次实验 马踏棋盘问题](https://img.taocdn.com/s3/m/e4ed5af9be23482fb4da4cdd.png)
#include<stdio.h>
#include<stdlib.h>
typedef struct
{
int x;
int y; //棋盘上的坐标
}Coordinate;
int chessboard[8][8];; //棋盘
int curstep; //马跳的步骤序号
Coordinate fangxiang[8]= //马可走的方向
桂林电子科技大学
数学与计算科学学院综合性、设计性实验报告
实验室:06406实验日期:2015年05月29日
院(系)
信息与计算科学系
年级、专业、班
1300710226
姓名
庞文正
成绩
课程
名称
数据结构实验
实验项目
名 称
马踏棋盘问题
指导
教师
教师
评语
教师签名:
年 月 日
一 ,实验目的
加深对图的理解,培养解决实际问题的编程能力。根据数据对象的特性,学会数据组织的方
19(4,4)
20(5,4)
11(1,3)
12(2,3)
13(3,3)
14(4,3)
15(5,3)
6(1,2)
7(2,2)
8(3,2)
9(4,2)
10(5,2)
1(1,1)
2(2,1)
3(3,1)
பைடு நூலகம்4(4,1)
5(5,1)
综合起来,马踏棋盘问题就可以转化为图的遍历问题。
三,使用仪器,材料
XP系统电脑一台,vc++软件!
{
printf("输入数值越界,请重新输入!\n");
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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 STACKSIZE70#define STACKINCREASE10typedef 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。
StackLength(s);初始条件:栈s存在。
操作结果:返回s的元素个数,即栈的长度。
GetTop(s,&e);初始条件:栈s已存在且非空。
操作结果:用e返回s的栈顶元素。
Push(&s,e)初始条件:栈s已存在。
操作结果:插入元素e为新的栈顶元素。
Pop(&s,&e)初始条件:栈s存在且非空。
操作结果:删除栈顶元素,并用e返回。
stackTraverse(s,visit())初始条件:栈s存在且非空。
操作结果:从栈底到栈顶依次对s的每个元素调用visit()。
一旦visit()失败,则操作失败。
}ADT Stack本程序包含模块:1、主程序模块:void main(){定义变量;接受命令;处理命令;退出;}2、起始坐标函数模块——马儿在棋盘上的起始位置;3、探寻路径函数模块——马儿每个方向进行尝试,直到试完整个棋盘;4、输出路径函数模块——输出马儿行走的路径;三.详细设计1.函数声明Void InitLocation(int xi,int yi);//马儿在棋盘上的起始位置标int TryPath(int i,int j);//马儿每个方向进行尝试,直到试完整个棋盘void Display();//输出马儿行走的路径2.起始坐标函数模块void InitLocation(int xi,int yi){int x,y;//定义棋盘的横纵坐标变量top++;//栈指针指向第一个栈首stack[top].i=xi;//将起始位置的横坐标进栈stack[top].j=yi;//将起始位置的纵坐标进栈stack[top].director=-1;//将起始位置的尝试方向赋初值board[xi][yi]=top+1;//标记棋盘x=stack[top].i;//将起始位置的横坐标赋给棋盘的横标y=stack[top].j;//将起始位置的纵坐标赋给棋盘的纵坐标if(TryPath(x,y))//调用马儿探寻函数,如果马儿探寻整个棋盘返回1否则0 Display();//输出马儿的行走路径elseprintf("无解");}3.探寻路径函数模块int TryPath(int i,int j){int find,director,number,min;//定义几个临时变量int i1,j1,h,k,s;//定义几个临时变量int a[8],b1[8],b2[8],d[8];//定义几个临时数组while(top>-1)//栈不空时循环{for(h=0;h<8;h++)//用数组a[8]记录当前位置的下一个位置的可行路径的条数{number=0;i=stack[top].i+Htry1[h];j=stack[top].j+Htry2[h];b1[h]=i;b2[h]=j;if(board[i][j]==0&&i>=0&&i<8&&j>=0&&j<8)//如果找到下一位置{for(k=0;k<8;k++){i1=b1[h]+Htry1[k];j1=b2[h]+Htry2[k];if(board[i1][j1]==0&&i1>=0&&i1<8&&j1>=0&&j1<8)//如果找到下一位置number++;//记录条数}a[h]=number;//将条数存入数组a[8]中}}for(h=0;h<8;h++)//根据可行路径条数小到大按下表排序放d[8]中{min=9;for(k=0;k<8;k++)if(min>a[k]){min=a[k];d[h]=k;//将下表存入数组d[8]中s=k;}a[s]=9;}director=stack[top].director;if(top>=63)//如果走完整个棋盘返回1return(1);find=0;//表示没有找到下一个位置for(h=director+1;h<8;h++)//向八个方向进行探寻{i=stack[top].i+Htry1[d[h]];j=stack[top].j+Htry2[d[h]];if(board[i][j]==0&&i>=0&&i<8&&j>=0&&j<8)//如果找到下一位置{find=1;//表示找到下一个位置Break;}}if(find==1)//如果找到下一个位置进栈{stack[top].director=director;//存储栈结点的方向top++;//栈指针前移进栈stack[top].i=i;stack[top].j=j;stack[top].director=-1;//重新初始化下一栈结点的尝试方向board[i][j]=top+1;//标记棋盘}else//否则退栈{board[stack[top].i][stack[top].j]=0;//清除棋盘的标记top--;//栈指针前移退栈}}return(0);}4.输出路径函数模块void Display(){int i,j;for(i=0;i<N;i++){for(j=0;j<N;j++)printf("\t%d",board[i][j]);//输出马儿在棋盘上走过的路径printf("\n\n");}printf("\n");}四、测试数据及测试结果测试数据:x=2,y=3测试结果如下:五.原程序代码#include<stdio.h>#define MAXSIZE100#define N8int board[8][8];//定义棋盘int Htry1[8]={1,-1,-2,2,2,1,-1,-2};/*存储马各个出口位置相对当前位置行下标的*/int Htry2[8]={2,-2,1,1,-1,-2,2,-1};/*存储马各个出口位置相对当前位置列下标的增量数组*/ struct Stack{//定义栈类型int i;//行坐标int j;//列坐标int director;//存储方向}stack[MAXSIZE];//定义一个栈数组int top=-1;//栈指针void InitLocation(int xi,int yi);//马儿在棋盘上的起始位置坐标int TryPath(int i,int j);//马儿每个方向进行尝试,直到试完整个棋盘void Display();//输出马儿行走的路径void InitLocation(int xi,int yi){int x,y;//定义棋盘的横纵坐标变量top++;//栈指针指向第一个栈首stack[top].i=xi;//将起始位置的横坐标进栈stack[top].j=yi;//将起始位置的纵坐标进栈stack[top].director=-1;//将起始位置的尝试方向赋初值board[xi][yi]=top+1;//标记棋盘x=stack[top].i;//将起始位置的横坐标赋给棋盘的横坐标y=stack[top].j;//将起始位置的纵坐标赋给棋盘的纵坐标if(TryPath(x,y))//调用马儿探寻函数,如果马儿探寻整个棋盘返回1否则返回0 Display();//输出马儿的行走路径elseprintf("无解");}int TryPath(int i,int j){int find,director,number,min;//定义几个临时变量int i1,j1,h,k,s;//定义几个临时变量int a[8],b1[8],b2[8],d[8];//定义几个临时数组while(top>-1)//栈不空时循环{for(h=0;h<8;h++)//用数组a[8]记录当前位置的下一个位置的可行路径的条数{number=0;i=stack[top].i+Htry1[h];j=stack[top].j+Htry2[h];b1[h]=i;b2[h]=j;if(board[i][j]==0&&i>=0&&i<8&&j>=0&&j<8)//如果找到下一位置{for(k=0;k<8;k++){i1=b1[h]+Htry1[k];j1=b2[h]+Htry2[k];if(board[i1][j1]==0&&i1>=0&&i1<8&&j1>=0&&j1<8)//如果找到下一位置number++;//记录条数}a[h]=number;//将条数存入数组a[8]中}}for(h=0;h<8;h++)//根据可行路径条数小到大按下表排序放入数组d[8]中{min=9;for(k=0;k<8;k++)If(min>a[k]){min=a[k];d[h]=k;//将下表存入数组d[8]中s=k;}a[s]=9;}director=stack[top].director;if(top>=63)//如果走完整个棋盘返回1return(1);find=0;//表示没有找到下一个位置for(h=director+1;h<8;h++)//向八个方向进行探寻{i=stack[top].i+Htry1[d[h]];j=stack[top].j+Htry2[d[h]];if(board[i][j]==0&&i>=0&&i<8&&j>=0&&j<8)//如果找到下一位置{find=1;//表示找到下一个位置break;}}if(find==1)//如果找到下一个位置进栈{stack[top].director=director;//存储栈结点的方向top++;//栈指针前移进栈stack[top].i=i;stack[top].j=j;stack[top].director=-1;//重新初始化下一栈结点的尝试方向board[i][j]=top+1;//标记棋盘}else//否则退栈{board[stack[top].i][stack[top].j]=0;//清除棋盘的标记top--;//栈指针前移退栈}}return(0);}void Display(){int i,j;for(i=0;i<N;i++){for(j=0;j<N;j++)printf("\t%d",board[i][j]);//输出马儿在棋盘上走过的路径printf("\n\n");}printf("\n");}int main(){int i,j;int x,y;for(i=0;i<N;i++)//初始化棋盘for(j=0;j<N;j++)board[i][j]=0;for(;;){printf("Please input importpoint(1<=x<=8and1<=y<=8)\n");printf("Input x=");scanf("%d",&x);//输入起始位置的横坐标printf("Input y=");scanf("%d",&y);//输入起始位置的纵坐标if(x>=1&&x<=8&&y>=1&&y<=8)break;printf("Your input is worng\n");}printf("begin with%d board:\n\n",8*(x-1)+y);InitLocation(x-1,y-1);//调用起始坐标函数}。