数据结构课程设计之九宫格

合集下载

java课程设计九宫格数独

java课程设计九宫格数独

计算机与信息工程系《数独游戏的设计与实现》课程设计2013-2014学年第二学期《面向对象程序设计》课程设计报告题目:九空格数独游戏的设计与实现专业:计算机科学与技术班级:12级计科(1)班姓名:程龙军指导教师:陈磊成绩:计算机与信息工程系2014年 6 月 6 日目录一、题目描述 (3)二、设计分析 (3)1、基本解法 (3)2、软件系统的功能 (4)3、对性能的要求 (4)三、设计思路 (5)1、分析找出问题域中的对象 (5)2、确定类的属性 (5)3、确定对象之间的关系 (5)四、系统设计 (6)五、源代码 (13)六、系统设计和软件发布 (24)1、程序运行情况 (24)2、软件的发布 (28)3、分析讨论 (29)七、难点及关键技术分析 (30)八、心得体会 (30)九、参考文献 (31)一、题目(问题)描述在9×9格的大九宫格中有9个3×3格的小九宫格,并提供一定数量的数字。

根据这些数字,利用逻辑和推理,在其它的空格上填入1到9的数字。

每个数字在每个小九宫格内只能出现一次,每个数字在每行、每列也只能出现一次。

这种游戏只需要逻辑思维能力,与数字运算无关。

虽然玩法简单,但数字排列方式却千变万化,所以不少教育者认为数独是锻炼脑筋的好方法。

二、设计分析1、基本解法:利用1 ~ 9 的数字在每一行、每一列、每一宫都只能出现一次的规则进行解题的方法。

实际寻找解的过程为:使用单元排除法的目的就是要在某一单元(即行,列或区块)中找到能填入某一数字的唯一位置,换句话说,就是把单元中其他的空白位置都排除掉。

那么要如何排除其余的空格呢?当然还是不能忘了游戏规则,由于1-9的数字在每一行、每一列、每一个九宫格都要出现且只能出现一次,所以:如果某行中已经有了某一数字,则该行中的其他位置不可能再出现这一数字如果某列中已经有了某一数字,则该列中的其他位置不可能再出现这一数字如果某区块中已经有了某一数字,则该区块中的其他位置不可能再出现这一数字。

大班幼儿九宫格教案及反思

大班幼儿九宫格教案及反思

大班幼儿九宫格教案及反思一、教学内容本节课选自大班幼儿数学教材第四章《有趣的图形——九宫格》。

详细内容包括:认识九宫格的基本结构,学习九宫格的规律,通过实践活动掌握九宫格的基本操作。

二、教学目标1. 了解九宫格的基本结构,能正确填写九宫格。

2. 学会运用九宫格规律解决问题,提高逻辑思维能力。

3. 培养幼儿的观察力、专注力和团队协作能力。

三、教学难点与重点教学难点:九宫格的规律掌握和运用。

教学重点:九宫格的基本结构和操作。

四、教具与学具准备教具:九宫格模板、九宫格卡片、磁性九宫格、多媒体课件。

学具:幼儿用九宫格练习册、九宫格卡片、画笔、剪刀。

五、教学过程1. 实践情景引入(5分钟)教师出示一个有趣的九宫格游戏,引导幼儿观察并尝试找出其中的规律。

2. 例题讲解(10分钟)教师通过多媒体课件,讲解九宫格的基本结构,引导幼儿学习九宫格的规律。

3. 随堂练习(10分钟)幼儿分组进行九宫格练习,教师巡回指导,帮助幼儿解决问题。

4. 小组讨论(5分钟)各小组分享自己的练习成果,讨论九宫格的规律和操作方法。

六、板书设计1. 九宫格的基本结构2. 九宫格的规律3. 九宫格的操作方法七、作业设计1. 作业题目:完成九宫格练习册中的练习题。

答案:略2. 拓展作业:设计一个九宫格游戏,与同伴分享。

八、课后反思及拓展延伸重点和难点解析1. 教学难点与重点的设定2. 教具与学具的准备4. 作业设计5. 课后反思及拓展延伸详细补充和说明:一、教学难点与重点的设定教学难点:九宫格的规律掌握和运用。

说明:九宫格规律的掌握和运用是本节课的核心,教师需通过多种教学手段和实践活动,帮助幼儿理解和内化这一概念。

对于幼儿来说,九宫格的规律可能较为抽象,因此,教师应设计直观、有趣的教具和学具,使幼儿能够通过动手操作,感受九宫格的规律。

教学重点:九宫格的基本结构和操作。

说明:九宫格的基本结构是学习九宫格规律的基础。

教师应着重讲解九宫格的构成,让幼儿熟悉九宫格的布局。

教学设计九宫格范文

教学设计九宫格范文

教学设计九宫格范文教学设计:九宫格主题:认识九宫格教学目标:1.学生能够理解九宫格的基本概念和特点。

2.学生能够准确描述九宫格的形状和结构。

3.学生能够应用九宫格解决简单问题。

教学内容:1.九宫格的定义和特点。

2.九宫格的结构和形状。

3.九宫格的应用。

教学过程:一、导入(10分钟)1.引入主题:老师展示一个九宫格图片,并提问:“你们知道这是什么吗?”学生进行回答。

2.引导学生思考九宫格的定义和特点:“你们能否告诉我九宫格的定义和特点是什么呢?”3.提示:九宫格是由3行3列的方格组成的,特点是每行、每列以及对角线上的数字之和都相等。

二、探究(20分钟)1.学生围绕九宫格的结构和形状进行探究。

2.老师以示例的形式给出一个九宫格,并引导学生找出九宫格中的特点(每行、每列以及对角线上的数字之和都相等)。

3.学生分组合作,自己设计一个九宫格,并验证是否符合九宫格的特点。

4.学生展示自己设计的九宫格,并发表观点。

三、概念巩固(15分钟)1.教师讲解例题:“如何使用九宫格求解问题?”2.示例:给出一个九宫格,要求填入1到9的数字,使得每行、每列以及对角线上的数字之和都相等。

3.学生在纸上完成例题并交换答案,互相核对。

四、拓展应用(15分钟)1.分组活动:老师给出一些九宫格问题,要求学生以小组为单位解决问题。

2.问题可以包括:使用九宫格填充数字,找规律等等。

3.学生展示自己的解决方法,并进行讨论和分享。

五、总结(10分钟)1.教师进行总结,巩固学生对九宫格的认识和应用。

2.提醒学生九宫格的特点和解决问题的方法。

六、作业布置(5分钟)1.布置作业:让学生回家完成一道九宫格相关的问题,并要求写出解题步骤和答案。

2.提醒学生按时完成并交作业。

教学评价:1.在教学过程中,教师观察学生的学习情况,通过讨论和展示等方式评价学生的学习效果。

2.作业中,教师可以针对学生解决问题的步骤和答案进行评价。

扩展:1.如果学生掌握了九宫格的基本概念,可以引导学生尝试解决更复杂的九宫格问题,如九宫格中有一些已填的数字,要求学生完成剩下的数字。

1512 重排九宫

1512 重排九宫

【数据结构•hash表】重排九宫Time Limit:10000MS Memory Limit:65536KTotal Submit:85 Accepted:33Description我先来说几句:============================================================= =======================================下面大家即将见到的是一道经典的广度搜索(bfs)题,bfs算法的运行耗时主要集中在状态扩展和状态判重上,大部分情况下,状态判重的耗时是远大于状态扩展的(假设可能扩展的状态数量为n,则其运算量分别为:o(n)和o(n^2)),如果在bfs算法中使用hash表去判重,则可以极大的提高运行效率。

因此,bfs+hash,会是解决相当多搜索题的杀手锏!就下面例题而言,注意到每种状态构成了一个排列,我们可以给它分配一个编号,总共的状态数不会超过9!=362880种。

(关于排列直接换算分配hash地址,可以见P1511理论基础知识,因此题状态数比较少,你可以使用简化的散列(hash)函数解决此题)。

============================================================= =======================================问题来了,重排九宫:将数字1~8按照人依次序排在3*3的方格阵列中,留下一个空位供数字方块移动,游戏的最终目标是通过合法移动将数字按行排好序。

输入举例:目标:输出达到目标状态的最少移动次数。

Input3*3的输入方阵,格式见样例。

Output一个整数,达到目标状态的最少移动次数。

Sample Input1 2 34 0 67 5 8Sample Output2Hint本题测试数据贡献者:东莞中学初中部肖遥Source∙const x:array[1..4] of longint=(0,0,1,-1);∙ y:array[1..4] of longint=(1,-1,0,0);∙ fac:array[1..9] oflongint=(1,1,2,6,24,120,720,5040,40320);∙ m=362877;∙ c=46234;∙type arr=array[1..3,1..3] of longint;∙var i,j,w,f,t,ii,d,i2:longint;∙ k:int64;∙ p,b:array[0..362880] of longint;∙ q:arr;∙ a:array[0..362880] of record a:arr; b:longint; end;∙∙function get(q:arr):int64;∙var i,j,temp:integer;∙ s:array[1..9] of longint;∙ num:longint;∙begin∙ num:=0;∙ for i:=1 to 3 do∙ for j:=1 to 3 do s[(i-1)*3+j]:=q[i,j];∙ for i:=1 to 8 do begin∙ temp:=0;∙ for j:=i+1 to 9 do∙ if s[j]<s[i] then inc(temp);∙ num:=num+fac[10-i]*temp; {1*8!+1*7!+...+1*0!, 1 2 3 4 5 67 8 0}∙ end;∙ get:=num+1;∙end;∙∙begin∙for i:=1 to 3 do∙ for j:=1 to 3 do begin∙ read(q[i,j]); inc(q[i,j]);∙ end;∙k:=get(q);∙if k=c then begin∙ writeln(0); halt;∙end;∙p[k mod m]:=k;∙f:=1; t:=1; a[1].a:=q; a[1].b:=0;∙∙while f<=t do begin∙ q:=a[f].a;∙ for i:=1 to 3 do begin∙ for j:=1 to 3 do if q[i,j]=1 then break;∙ if q[i,j]=1 then break;∙ end;∙∙ for ii:=1 to 4 do if ((i+x[ii]) in[1..3])∙ and ((j+y[ii]) in[1..3]) then begin∙ w:=q[i,j]; q[i,j]:=q[i+x[ii],j+y[ii]];q[i+x[ii],j+y[ii]]:=w;∙ k:=get(q);∙ if k=c then begin∙ writeln(a[f].b+1); halt;∙ end;∙∙ d:=k mod m;∙ while (b[d]<>0) and (p[d]<>k) do d:=d+b[d]; ∙ if p[d]<>k then begin∙ i2:=1;∙ while p[d+i2]<>0 do inc(i2);∙ b[d]:=i2; p[d+i2]:=k;∙ inc(t); a[t].a:=q; a[t].b:=a[f].b+1;∙ end;∙ w:=q[i,j]; q[i,j]:=q[i+x[ii],j+y[ii]];q[i+x[ii],j+y[ii]]:=w;∙ end;∙ inc(f);∙end;∙end.。

大班数学活动九宫格

大班数学活动九宫格

大班数学活动:拼九方格图活动目标:1、认识九方格图和拼图卡,能在作业单上记录自己的拼图方法。

2、学习多角度思考问题,进行多种组合,寻求多种答案。

3、感受拼图游戏奇妙之处,在操作活动中获得成功的体验。

活动准备:1、教具:九方格课件2、学具:九方格底板、拼图卡(8套)、记录单、活动过程:一、认识九方格图、拼图卡,尝试用不同方法拼九方格图1、出示课件,认识九方格图、拼图卡。

(1)、认识九方格图师:今天老师给大家带来了一个图形,请小朋友仔细观察它是由几个什么图形拼成的,有什么排列规律?(幼儿相互讨论,回答问题)(2)认识拼图卡师:这些拼图卡一样吗?哪里不一样?(形状、颜色、组合方式不一样),但是它们有一个共同的特征是什么?(都是由小正方形组合而成的),这些小正方形和九方格图中的小正方形一样大吗?(请一名幼儿上来操作验证。

)2、尝试多种九方格图的拼法,学习记录拼图方法。

(1)尝试多种九方格拼图方法。

师:谁会用这些拼图卡来拼一拼九方格图呢?(幼儿上来操作,鼓励幼儿大胆尝试多种拼法)(2)游戏“闯关游戏”出示ppt幼儿尝试根据要求拼九方格。

3、尝试学习在记录单上记录自己的拼图方法。

怎样记才能清楚地记录自己分别是用哪些图形板拼出九方格图案的?(提示幼儿看拼图卡上的编号记录)二、交代要求,幼儿操作,教师巡回指导。

幼儿自由拼九方格图,并记录结果。

“你会用这些拼图卡拼九方格图吗?请每个小朋友试一试,可别忘记记录你的拼图方法哦!”三、评价活动展示个别幼儿的拼图记录单,集体进行展评。

师:今天我们发现了一个小秘密,拼九方格图有很多的不同拼法,我们一起比一比看谁拼的方法最多。

数据结构课程设计

数据结构课程设计

数据结构课程设计数独是源自18世纪瑞士的一种数学游戏。

是一种运用纸、笔进行演算的逻辑游戏。

玩家需要根据9×9盘面上的已知数字,推理出所有剩余空格的数字,并满足每一行、每一列、每一个粗线宫(3*3)内的数字均含1-9,不重复。

数独盘面是个九宫,每一宫又分为九个小格。

在这八十一格中给出一定的已知数字和解题条件,利用逻辑和推理,在其他的空格上填入1-9的数字。

使1-9每个数字在每一行、每一列和每一宫中都只出现一次,所以又称“九宫格”。

请设计一个数独游戏,要求包括:1,基本要求:能按照不同难度级别设置随机的初始数独,允许用户在空格处填入数字完成数独游戏;在用户输入数字时,判断冲突,给出错误提示;计时,记录用户完成数独所用时间。

2,补充要求:设计出具有唯一解的数独布局;设计出更符合实际情况的难度值;不使用回溯算法快速求解数独。

建议使用JavaScript/HTML/CSS编程,使用回溯算法。

交付品包括1,课程设计报告:包括开发目标,开发计划,测试方案,软件设计(用方框图表示软件结构,用流程图或伪代码表示算法),软件实现(给出关键函数的代码清单),测试结果与分析,总结2,源代码3,结果展示(以PPT或小视频文件实现)交付方式1.时间:不迟于2017年1月7日晚上23:592.交付品1,2,3上传至班级钉盘公共区的“课程设计”文件夹,以自己姓名+学号新建目录3.交付品1交给各班学习委员,2017年1月10日下午统一交给老师参考资料[1]百度百科,/link?url=aWe4mbeQl9PRkh0qrqXu2sQ_88 kKo7IE9SIi7DZTvX0zDh-lULYs9QRZYAJijQUS2t-_Wh2deFkK d5giJH-XTIGm3YZXU7Ku_cJIRgRxHdG[2]维基百科,https:///wiki/Sudoku。

2024年大班数学教案—九宫格

2024年大班数学教案—九宫格

2024年大班数学教案—九宫格教案概述:课程名称:大班数学——九宫格游戏教学目标:通过九宫格游戏,让学生掌握简单的数字排列规律,提高观察能力和逻辑思维能力。

教学准备:九宫格游戏卡片、数字卡片、计时器教学过程:一、导入1.老师拿出九宫格游戏卡片,引导学生观察,并提问:“同学们,你们知道这是什么吗?”2.学生回答后,老师简要介绍九宫格游戏。

二、基本概念1.老师展示九宫格游戏卡片,引导学生观察九宫格的特点。

2.学生观察后,老师提问:“九宫格有什么特点?”三、数字排列规律1.老师展示数字卡片,引导学生观察数字的排列规律。

2.学生观察后,老师提问:“你们发现了什么规律?”四、游戏实践1.老师将九宫格游戏卡片和数字卡片分发给每个小组。

2.老师宣布游戏规则:每个小组在规定时间内,将数字卡片按照一定的顺序填入九宫格中。

3.游戏开始,学生开始填写九宫格。

4.老师观察学生的操作,适时给予指导和鼓励。

5.游戏结束,老师宣布时间到,收齐九宫格游戏卡片。

1.老师邀请学生分享游戏过程中的心得体会。

一、导入1.老师拿出九宫格游戏卡片,引导学生观察。

师:同学们,你们知道这是什么吗?生:九宫格!师:没错,这就是我们今天要学习的九宫格游戏。

你们想不想玩?生:想!2.老师简要介绍九宫格游戏。

师:九宫格游戏是一种数字游戏,我们需要在九个方格中填入数字,使它们满足一定的规律。

二、基本概念1.老师展示九宫格游戏卡片,引导学生观察九宫格的特点。

师:请大家仔细观察九宫格,你们发现了什么特点?生:九宫格是由九个方格组成的!师:没错,九宫格就是由九个方格组成的,每个方格内可以放置一个数字。

2.老师提问:“九宫格有什么特点?”生:九宫格是由九个方格组成的!三、数字排列规律1.老师展示数字卡片,引导学生观察数字的排列规律。

师:请大家仔细观察这些数字卡片,你们发现了什么规律?生:数字卡片上的数字是按照从小到大的顺序排列的!师:很好,那我们再来观察一下,这些数字卡片上的数字是按照从大到小的顺序排列的吗?生:不是!2.老师提问:“你们发现了什么规律?”生:数字卡片上的数字是按照一定的顺序排列的!四、游戏实践1.老师将九宫格游戏卡片和数字卡片分发给每个小组。

十字链表和九宫格算法

十字链表和九宫格算法

十字链表和九宫格算法全文共四篇示例,供读者参考第一篇示例:十字链表和九宫格算法是两种经典的数据结构和算法,在计算机科学领域中具有重要的应用价值。

本文将介绍这两种算法的原理、特点及应用场景,以帮助读者更深入地理解它们。

首先,我们来看看十字链表算法。

十字链表是一种用于表示稀疏矩阵的数据结构,它能够高效地存储和检索稀疏矩阵中的非零元素。

在十字链表中,每个非零元素都会被封装成一个节点,并且节点之间通过指针相互连接,形成一个十字形的链表结构,从而方便对矩阵进行高效的操作。

十字链表算法的核心思想是将原本存储在二维数组中的稀疏矩阵转换成一个链表的形式,从而减少存储空间的消耗和提高检索效率。

通过使用指针连接的方式,可以方便地访问任意一个非零元素,并且在进行矩阵运算时能够大大提高运算效率。

十字链表算法在图论、线性代数和计算机图形学等领域都有广泛的应用。

比如在图论中,可以利用十字链表算法来存储图的邻接矩阵,并且通过遍历链表来查找图中的路径和环路。

在计算机图形学中,可以使用十字链表算法来表示图像的稀疏像素点,从而实现图像的压缩和处理。

接下来,我们来介绍一下九宫格算法。

九宫格算法是一种常用的数独解题算法,它通过递归和回溯的方式来解决数独难题,求解出数独题目的唯一解。

在数独游戏中,每个九宫格都由9个小格子组成,玩家需要填入1-9的数字,使得每一行、每一列和每个九宫格内的数字都不重复。

九宫格算法的核心思想是从数独题目的第一个空格开始逐个填入数字,然后检查当前数字是否符合数独规则。

如果符合规则,则填入下一个空格,依次递归进行。

如果填入的数字不符合规则,则回溯到上一个位置,重新填入其他数字,直到找到正确的解。

九宫格算法在解决数独难题和其他逻辑推理问题上有着重要的应用。

通过使用递归和回溯的方式,可以高效地求解出数独题目的解,并且在解决其他逻辑谜题时也能够发挥重要作用。

总的来说,十字链表算法和九宫格算法都是计算机科学中重要的数据结构和算法,它们在不同领域有着广泛的应用价值。

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

#include<stdio.h>#include<string.h>#include<stdlib.h>#include <windows.h>#include"Basic_Operation.h"#define U 56//up#define D 57//down#define L 58//left#define R 59//righttypedef struct LNode{int data;//用一个各位不相等的9位数来表示当前状态,9表示空格int flag;//0表示由初始状态生成,1表示由末状态生成int fangxaing;//表示双亲结点生成此结点时空格的移动方向char *path;//存放路径的数组下标,比实际值小1struct LNode *next,*next1;//next用于队列中,next1用于链表}LNode,*Linklist;typedef struct {Linklist front,rear;}LinkQueue,*Queue;void gotoxy(int x, int y){int xx=0x0b;HANDLE hOutput;COORD loc;loc.X=x;loc.Y=y;hOutput = GetStdHandle(STD_OUTPUT_HANDLE);SetConsoleCursorPosition(hOutput, loc);return;}void HideCursor(){CONSOLE_CURSOR_INFO cursor_info = {1, 0};SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info); }int InitQueue(Queue Q){Q->front=(Linklist)malloc(sizeof(LNode));Q->rear=Q->front;return 1;}int EnQueue(Queue Q,Linklist tem){Q->rear->next=tem;Q->rear=tem;return 0;}int dequeue(Queue Q,Linklist *tem) {*tem=Q->front->next;Q->front=Q->front->next;return 0;}int DestroyQueue(Queue Q){Linklist tem,tem1;if(Q->front==Q->rear)return 0;dequeue(Q,&tem);while(Q->front!=Q->rear){tem1=Q->front;dequeue(Q,&tem);free(tem1->path);free(tem1);}free(Q->rear->path);free(Q->rear);return 0;}int Destroylist(Linklist a){Linklist tem;while(a->next1!=0){tem=a;a=a->next1;free(tem->path);free(tem);}return 1;}void swap(char *a,char *b){char tem;tem=*a;*a=*b;*b=tem;}int InitLNode(Linklist *M,char *b,int n){int temp;(*M)=(Linklist)malloc(sizeof(LNode));sscanf(b,"%d",&(*M)->data);(*M)->path=(char*)malloc(2*sizeof(char));for(temp=0;temp<9;temp++)//找到空格所在位置if(b[temp]=='9')break;(*M)->path[0]=temp+48;(*M)->path[1]=0;(*M)->flag=n;(*M)->fangxaing=0;return 0;}int check(char a[]);//检测初始状态是否有解int search(char a[],char **path);//寻找解。

将路径存入pathvoid print(char *path);//输出路径void move(char *data,char *path);//动态演示int main(void){int flag=1;//flag为0时退出char a[9]={0};char b[9]={0};char *path;char tem;while(flag){printf("请以字符串形式输入九宫格初始状态,空格用9表示。

例如:\n");printf("初始状态┌─┬─┬─┐\n");printf("\t│ 1│ 2│ 3│\n");printf("\t├─┼─┼─┤\n");printf("\t│ 4│ 5│ 6│\n");printf("\t├─┼─┼─┤\n");printf("\t│ 7│ 8││\n");printf("\t└─┴─┴─┘\n");printf("输入\"123456789\"\n");scanf("%s",a);getchar();//把回车吃掉strcpy(b,a);if(check(b)){printf("unsolvable\n");printf("输入Y测试下一个九宫格,输入其他任意键退出\n");}else{printf("空格所经路径为\n");search(a,&path);print(path);move(a,path);gotoxy(30,13);printf("输入Y测试下一个九宫格,输入其他任意键退出\n");gotoxy(30,14);}tem=getchar();getchar();//把回车吃掉if(tem=='y'||tem=='Y'){system("cls");}else{flag=0;}}return 0;}int check1(int n,char a[]){int i,m=0;for(i=0;i<n;i++)if(a[i]>a[n])m++;return m;}int check(char a[]){int i,tem=0;for(i=0;i<9;i++)//找到空格所在位置if(a[i]=='9')break;while(i<6){swap(&a[i],&a[i+3]);i=i+3;}while(i<8){swap(&a[i],&a[i+1]);i=i+1;}//将空格置于右下角的位置来推算是否成立。

数学原理如下:/*假设图中的a是3*3数字拼图标准的结果,则对于图b的状态是不可能变换成a的。

证明起来需要用到高等代数里逆序数的概念,具体的说是用到了一个简单的定理。

定义:在一个1,2,...,n的排列中,如果一对数的前后位置与大小顺序相反,即前面的数大于后面的数,那么它们就称为一个逆序。

一个排列中逆序的总数就称为这个排列的逆序数。

逆序数为偶数的排列称为偶排列;逆序数为奇数的排列称为奇排列。

如2431中,21,43,41,31是逆序,逆序数是4,为偶排列。

——这是北大《高等代数》上的定义。

定理:交换一个排列中的两个数,则排列的奇偶性发生改变。

(证明见任何一本《高等代数》)我们将空格看成数字9(数字9对应空位),按正常顺序看a图,9个数字排列是123456789,其逆序数是0,是偶排列;b图是123456879,逆序数是1,是奇排列。

我们知道,我们能够移动空块相邻的块,这里的移动相当于一种特殊的对换(相邻对换),例如:对于b图,移动6就相当于9和6互换(9向上移动了),移动7就相当于9和7互换(9向左移动了)。

现在假设从b图经过一系列的平移变到了a图,则空格块9必然移动(对换)了偶数次(向左一次必然要再向右一次回来,向上一次必然要向下再回来,最终才能够回到右下角的位置),根据上面的定理最终变成的排列必然是仍然是奇排列(和b相同),然而a图是偶排列,因而产生矛盾,因此b图不可能通过平移变成最终的a图。

*/ for(i=0;i<9;i++)//求逆置数{tem=tem+check1(i,a);}return tem%2;}void nextpath(Linklist parent,Linklist child,int n){child->path=(char*)malloc(strlen(parent->path)+2);strcpy(child->path,parent->path);child->path[strlen(parent->path)]=n+48;child->path[strlen(parent->path)+1]=0;}int next(Linklist parent,Linklist *child,int flag){char tem[10]={0};int temp;sprintf(tem,"%d",parent->data);*child=(Linklist)malloc(sizeof(LNode));for(temp=0;temp<9;temp++)//找到空格所在位置if(tem[temp]=='9')break;switch(flag){caseU:swap(&tem[temp],&tem[temp-3]);nextpath(parent,*child,temp-3);break;caseD:swap(&tem[temp],&tem[temp+3]);nextpath(parent,*child,temp+3);break;caseL:swap(&tem[temp],&tem[temp-1]);nextpath(parent,*child,temp-1);break;caseR:swap(&tem[temp],&tem[temp+1]);nextpath(parent,*child,temp+1);break;}(*child)->flag=parent->flag;sscanf(tem,"%d",&((*child)->data));(*child)->fangxaing=flag;return 0;}int f(int n){//哈希函数int m=0,i,a[8]={40320,5040,720,120,24,6,2,1};char tem[9];sprintf(tem,"%d",n);for(i=0;i<8;i++){m=m+(tem[i]-49+check1(i,tem)-i)*a[i];}//a=((n/100000000)-1)*40320+(((n%100000000)/10000000)-1)*5040+(((n%10000000)/1 000000)-1)*720+(((n%1000000)/100000)-1)*120;//m=a+(((n%100000)/10000)-1)*24+(((n%10000)/1000)-1)*6+(((n%1000)/100)-1)*2+(( (n%100)/10)-1);return m+1;}int inhxb(Linklist tem,Linklist a[]){//哈希函数为所有比表示这个状态的各位不相等的九位数小的各位不相等的九位数的个数,所以不会产生冲突//将tem放入正确的位置,并利用结点中的next构造一个头结点为hxb[0]的单链表便于之后释放空间int n,m;n=tem->data;m=f(n);a[m]=tem;tem->next1=a[0];a[0]=tem;return 1;}int bfs(Queue Q,Linklist parent,Linklist hxb[]){//对结点tem进行宽度优先搜索,并将子状态入队列,int m,x,y;//x,y表示空格在3*3矩阵中的位置,char temp[9];Linklist child;m=f(parent->data);if(hxb[m]!=0){if(hxb[m]->flag==parent->flag)return 1;elsereturn 0;}inhxb(parent,hxb);//进入已搜索的列表sprintf(temp,"%d",parent->data);for(m=0;m<9;m++)//找到空格所在位置if(temp[m]=='9')break;y=m%3+1;x=m/3+1;if(x<3&&parent->fangxaing!=U){next(parent,&child,D);EnQueue(Q,child);}if(x>1&&parent->fangxaing!=D){next(parent,&child,U);EnQueue(Q,child);}if(y<3&&parent->fangxaing!=L){next(parent,&child,R);EnQueue(Q,child);}if(y>1&&parent->fangxaing!=R){next(parent,&child,L);EnQueue(Q,child);}return 1;}int search(char a[],char **path){LinkQueue m,n;//分别用于从初始状态,以及末状态同步开始的两路搜索Linklist l1,l2,temp1,temp2;Linklist *hxb;//哈希表hxb=(Linklist*)calloc(362881,sizeof(Linklist));hxb[0]=(Linklist)malloc(sizeof(LNode));hxb[0]->next1=0;int flag1=1,flag2=1,i,j,k;//找到结果时flag=0;i,j,k作为计数量使用char *b="123456789";InitLNode(&l1,a,0);//初始化节点l1,l2InitLNode(&l2,b,1);InitQueue(&m);//初始化队列m,nInitQueue(&n);EnQueue(&m,l1);//l1,l2入队列EnQueue(&n,l2);while(flag1&&flag2){dequeue(&n,&temp2);flag2=bfs(&n,temp2,hxb);dequeue(&m,&temp1);flag1=bfs(&m,temp1,hxb);}if(0==flag1){i=f(temp1->data);(*path)=(char*)malloc(strlen(temp1->path)+strlen(hxb[i]->path));strcpy((*path),temp1->path);for(j=strlen(temp1->path),k=strlen(hxb[i]->path)-1;k>=0;j++,k--) (*path)[j-1]=hxb[i]->path[k];}else{i=f(temp2->data);(*path)=(char*)malloc(strlen(temp2->path)+strlen(hxb[i]->path)+1);strcpy((*path),hxb[i]->path);for(j=strlen(hxb[i]->path),k=strlen(temp2->path)-1;k>=0;j++,k--) (*path)[j-1]=temp2->path[k];}(*path)[j-1]=0;DestroyQueue(&m);DestroyQueue(&n);Destroylist(hxb[0]);return 1;}void move(char *data,char *path){int x,y,m,n,tem,a,b;//x,y,m,n用于计算光标位置,a储存当前空格所在,b储存空格将要移动位置char *temp;temp=data;m=30;n=5;HideCursor();//隐藏光标for(tem=0;tem<9;tem++)//找到空格所在位置if(temp[tem]=='9')break;temp[tem]=' ';tem=n;gotoxy(m,n++);printf("动态演示:");gotoxy(m,n++);printf("┌─┬─┬─┐");gotoxy(m,n++);printf("││││");gotoxy(m,n++);printf("├─┼─┼─┤");gotoxy(m,n++);printf("││││");gotoxy(m,n++);printf("├─┼─┼─┤");gotoxy(m,n++);printf("││││");gotoxy(m,n++);printf("└─┴─┴─┘");n=tem;for(x=1;x<4;x++)for(y=1;y<4;y++){gotoxy((m-1)+4*y,n+2*x);printf("%c",*temp++);}a=(*path)-48;path++;while((*path)!=0){Sleep(1500);b=(*path)-48;swap(&data[a],&data[b]);a=b;path++;temp=data;for(x=1;x<4;x++)for(y=1;y<4;y++){gotoxy((m-1)+4*y,n+2*x);printf("%c",*temp++);}}}void print(char *path){int x,y,m,i=0;while((*path)!=0){if((i%3)==0)printf("\n");m=(*path)-48;y=m%3+1;x=m/3+1;printf("(%d,%d) ",x,y);path++;i++;}printf("\n");system("Pause");}。

相关文档
最新文档