九宫格实现算法
实验目的：通过visual c++进行算法编辑，准确掌握算法运行方式及流程。
通过程序实现类似九宫格的拼图效果，也叫做八方块。用最快的时间实现最后的
效果：1 2 3
4 5 6
7 8 0
实验原理：先实现一个三行三列数组，再依次比较第一个数与上下左右数值的大小，进行移动，最后实现效果图。计算出一共移动的步数和每移一步的效果。
实验内容：
程序代码如下：
// 8block.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include
#include
#include
#define GOAL 123804765//表示我们要找得目标状态
struct Node
{
short state[9];//存放结点的状态
short pos;//空格所在的位置,在数组中用0代表空格
struct Node *up;//空格上移后的状态
struct Node *down;//空格下移后的状态
struct Node *left;//空格左移后的状态
struct Node *right;//空格右移后的状态
struct Node *parent;//它是从哪一状态变换而来的
struct Node *next;//表示在队列中的下一个状态
} ;
struct Tree
{
short key;//表示当前结点的数值
short * state;//表示当前状态的整个数组,当整颗树生成完毕后这一数组将被释
放
short index;//表示当前数值在数组中的位置
bool visited;//对于叶子结点而言，表示这一结点是否被访问过
struct Tree * next;//指向它的(下一个)兄弟结点，表示这一位置的下一个数
struct Tree *down;//指向它的第一个孩子结点，表示下一位置的第一个数};
struct Queue//定义一个队列用于广度优先遍历
{
struct Node * front;
struct Node * rear;
};
void InitQueue(struct Queue *Q);//初始化一个空队列
bool QueueEmpty(struct Queue *Q);//判断队列是否为空
void EnQueue(struct Queue *Q,struct Node *N);//入队列
struct Node * DeQueue(struct Queue *Q);//出队列，返回队结点
void ClearQueue(struct Queue *Q);//清空队列
struct Node * GetBestPath(struct Node *tree);//找到一个最短路径，并返回最后的状态结点，如果没有路径返回NULL
struct Tree * CreateCheckTree();//生成一个用于检查状态的查询树
void CreateSubCheckTree(struct Tree * T);//生成状态检查子树
void FreeCheckTree(struct Tree * checkTree);//释放状态检查树的空间
int checkCount=0;//检查结点状态次数
int deCount=0;//出队列次数
int enCount=0;//入队列次数
struct Tree * checkTree;
void main()
{
struct Node* tree=new struct Node;
tree->parent=NULL;
printf("输入0-8的任意一个排列，其中0表示空格所在的位置:\n");
for(int i=0;i<=8;i++)
{
scanf("%d",&tree->state[i]);
}
for(int i=0;i<=8;i++)
{
if(tree->state [i]==0)
{
tree->pos =i;
}
}
tree->next =NULL;
int c1=clock();
struct Node *result=GetBestPath(tree);
int c2=clock();
double t=(c2-c1)/1000.0;
printf("状态检查次数:%d,入队列次数:=%d,出队列次
数:%d\n",checkCount,enCount,deCount);
if(result!=NULL)
{
int path[200];
int count=0;
struct Node *N=result;
while(N!=NULL)
{
path[count]=N->pos;
N=N->parent;
count++;
}
printf("有最短路径，共须%d步。\n下面给出各步空格出现的位置(第一个数
为初始位置)：\n",count-1);
for(int i=count-1;i>=0;i--)
{
printf("%d ",path[i]);
}
}
else
{
printf("不存在路径!");
}
printf("\n所用时间为:%f秒",t);
getchar();
getchar();
}
void FreeCheckTree(struct Tree * checkTree)
{
if(checkTree->down!=NULL)
{
FreeCheckTree(checkTree->down);
}
if(checkTree->next!=NULL)
{
FreeCheckTree(checkTree->next);
}
delete checkTree;
}
struct Tree * CreateCheckTree()
{
struct Tree *T = new struct Tree;
T->index =0;
T->key =-1;
T->next =NULL;
T->down =NULL;
T->state =new short[10];
T->state[0]=-1;
for(int i=1;i<=9;i++)
{
T->state [i]=i-1;
}
CreateSubCheckTree(T);
return T;
}
void CreateSubCheckTree(struct Tree * T)
{
if(T->index==8)//如果前八个数都排好了
{
T->down =new struct Tree;
T->down->key =T->state[9];
T->down->visited =false;
T->down ->down =NULL;
T->down ->next =NULL;
delete T->state;
}
else
{
struct Tree *old=T;
for(int i=T->index+1;i<10;i++)
{
struct Tree *current=new struct Tree;
current->state =new short[10];
for(int j=0;j<=9;j++)
{
current->state [j]=T->state [j];
}
current->index =T->index +1;//将指针前移
current->next =NULL;
current->down =NULL;
current->key=current->state[i];//将关键字设置为当前i所指处
int temp=current->state[current->index];//以下三句完成交换
current->state[current->index]=current->state[i];
current->state[i]=temp;
if(i==T->index+1)//如果是第一个孩子
{
T->down=current;
old=current;
}
else
{
old->next =current;
old=current;
}
CreateSubCheckTree(current);
}
delete T->state;
}
}
bool checkNode(struct Node *N)
{
checkCount++;
struct Tree *current=checkTree;
for(int i=0;i<9;i++)
{
current=current->down;
while(N->state[i]!=current->key)
{
current=current->next;
}
}
if(current->visited==false)
{
current->visited =true;
return true;
}
else
{
return false;
}
}
struct Node * GetBestPath(struct Node *tree)//找到一个最短路径，并返回最后的状态结点，如果没有路径返回NULL
{
checkTree=CreateCheckTree();
// printf("分配完成!\n");
getchar();
int i;
struct Queue *Q=new struct Queue;
InitQueue(Q);
EnQueue(Q,tree);
while(!QueueEmpty(Q))
{
struct Node *N=DeQueue(Q);
int index=0;
for(i=0;i<=8;i++)
{
index=index*10+N->state[i];
}
if(index==GOAL)
{
FreeCheckTree(checkTree);
ClearQueue(Q);
return N;
}
if(N->pos>=3)//空格可以往上移
{
struct Node *up=new struct Node;
for(i=0;i<=8;i++)
{
up->state [i]=N->state [i];
}
up->state[N->pos]=up->state [N->pos-3];//完成上移
up->state [N->pos-3]=0;//同上
up->pos =N->pos-3;
if(checkNode(up))//如果这一状态以前没有出现过,保留这一状态{
N->up =up;
up->parent =N;
EnQueue(Q,up);
}
else//如果这一状态以前出现过，
{
delete up;
N->up =NULL;
}
}//空格可以往上移
if(N->pos<=5)//空格可以往下移
{
struct Node *down=new struct Node;
for(i=0;i<=8;i++)
{
down->state [i]=N->state [i];
}
down->state[N->pos]=down->state [N->pos+3];//完成下移
down->state [N->pos+3]=0;//同上
down->pos =N->pos+3;
if(checkNode(down))//如果这一状态以前没有出现过,保留这一状态{
N->down =down;
down->parent =N;
EnQueue(Q,down);
}
else//如果这一状态以前出现过，
{
delete down;
N->down =NULL;
}
}//空格可以往下移
if(N->pos!=0 && N->pos!=3 && N->pos!=6)//空格可以往左移
{
struct Node *left=new struct Node;
for(i=0;i<=8;i++)
{
left->state [i]=N->state [i];
}
left->state[N->pos]=left->state [N->pos-1];//完成上移
left->state [N->pos-1]=0;//同上
left->pos =N->pos-1;
if(checkNode(left))//如果这一状态以前没有出现过,保留这一状态{
N->left =left;
left->parent =N;
EnQueue(Q,left);
}
else//如果这一状态以前出现过，
{
delete left;
N->left =NULL;
}
}//空格可以往左移
if(N->pos!=2 && N->pos!=5 && N->pos!=8)//空格可以往右移
{
struct Node *right=new struct Node;
for(i=0;i<=8;i++)
{
right->state [i]=N->state [i];
}
right->state[N->pos]=right->state [N->pos+1];//完成上移
right->state [N->pos+1]=0;//同上
right->pos =N->pos+1;
if(checkNode(right))//如果这一状态以前没有出现过,保留这一状态
{
N->right =right;
right->parent =N;
EnQueue(Q,right);
}
else//如果这一状态以前出现过，
{
delete right;
N->right =NULL;
}
}//空格可以往右移
}
FreeCheckTree(checkTree);
return NULL;
}
void InitQueue(struct Queue *Q)//初始化一个空队列
{
struct Node * head=new struct Node;
head->next =NULL;
Q->front =head;
Q->rear=head;
};
bool QueueEmpty(struct Queue *Q)//判断队列是否为空
{
if(Q->front ==Q->rear )
{
return true;
}
else
{
return false;
}
};
void EnQueue(struct Queue *Q,struct Node *N)//入队列
{
enCount++;
Q->rear->next=N;
Q->rear=N;
struct Node * DeQueue(struct Queue *Q)//出队列，返回队结点{
deCount++;
if(Q->front ==Q->rear )
{
printf("队列已空!!\n");
return NULL;
}
else
{
struct Node *N=Q->front->next;
Q->front->next=N->next;
if(Q->rear==N)
{
Q->rear =Q->front;
}
return N;
}
}
void ClearQueue(struct Queue *Q)//清空队列
{
while(!QueueEmpty(Q))
{
delete(DeQueue(Q));
}
}
实验结果：
九宫格以及更高阶数的宫格算法与源程序
#include
return 0; } 魔方阵算法： （1）将1放在第一行中间一列 （2）从2开始直到n*n止个数一次按下列规则存放，每一个数存放的行比前一个数的列数减1，行数加1 （3）如果上一数的行数为1，，则下一个数的行数为n （4）当上一个数的列数为n时，下一个数的列数应为1，行数减1 （5）如果按上面的规则确定的位置上已有数，或上一个数是第一行的n列时，则把下一个数放在上一个数的下面 ————————算法很难理解 #include 数独 数独（すうどく，）是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。每一道合格的数独谜题都有且仅有唯一答案，推理方法也以此为基础，任何无解或多解的题目都是不合格的。 既然“数独”有一个字是“数”，人们也往往会联想到数学，那就不妨从大家都知道的数学家欧拉说起，但凡想了解数独历史的玩家在网络、书籍中搜索时，共同会提到的就是欧拉的“拉丁方块（）”，如下图： 拉丁方块的规则：每一行（）、每一列（）均含1（N即盘面的规格），不重复。这及前面提到的标准数独非常相似，但少了一个宫的规则。 其实说到这里，有些人会想到《易经》当中的洛书九宫图： 洛书九宫图 横、竖、斜方向的三数之和均是15，相信大家小学时候也都算过这个题目。所以也有人说数独的起源在中国。这点我们不得而知，但可以肯定的是，如今数独热潮已在全球蔓延。组成元素 1.九宫格（） 水平方向有九横行，垂直方向有九纵列的矩形，画分八十一个小矩形，称为九宫格()，如图一所示，是数独()的作用范围。 数独元素 - 九宫格 [1] 2.单元()画分 2.1 水平方向的每一横行有九格，每一横行称为行()，编号如图二所示。 数独元素 - 单元 2.2 垂直方向的每一纵列有九格，每一纵列称为列()，编号如图三所示。 数独元素 - 列 2.3 三行及三列相交之处有九格，每一单元称为小九宫(、)，简称宫，如图四用粗线标示者。（在数独中，宫往往用单词表示） 数独元素 - 宫 2.4 上述行、列、宫统称为单元() 2.5 由三个连续宫组成大区块(），分大行区块()及大列区块()。 第一大行区块：由第一宫、第二宫、第三宫组成。 第二大行区块：由第四宫、第五宫、第六宫组成。 第三大行区块：由第七宫、第八宫、第九宫组成。 第一大列区块：由第一宫、第四宫、第七宫组成。 九宫格算法攻略 早上看了一个关于大盗攻略的帖子，写的很详细(不是广告)，不过是比较早的，现在改了不少。我想说的是，看过发现好多亲都不会算9宫。 献个丑，帮大家想了一个简单的方法。(先说方法，后面再解释) 首先是准备工作：亲们需要把下面2组9宫格写在本本或者便利贴上面 九宫算法 好了，大盗给出的题目都是3个数字， 亲们只要把题目对照上图找好方位，依次排列9个数再消掉题目，就是我们要的答案了 (稀里糊涂拉?来举个例子吧) 例如题目为： 第一排第二个数：7 第三排第一个数：8 第三排第三个数：4 (一起来算一算吧) 回顶部 第一步：在上图中找到7，把这个【7】放到第一排第二个数的位置。 (也就是把图换个方向看看，这里就用到之前的准备工作啦) 现在我们来找找看，在图一中，三排一是【8】，那么图一就是我们这题需要的模型。 这时你会发现，图一现在的三排三，就是我们题目中的【4】。 第二步：把现在的图一9个数按顺序排列(熟练以后这一步可以省略) 6 7 2 1 5 9 8 3 4 第三步：消掉题目中给出的数字 6 2 1 5 9 3 这就是我们要的答案啦，亲们会算了吗? 下面来解释一下9宫格 第一，9宫格只有上图2种解法(事实上是一种，你会发现图二是图一的背面) 第二，9宫格的口诀：戴九履一，左三右七，二四有肩，八六为足，五居中央。 (这口诀是黄蓉说的，我就是这样记住的需要注意古代人认字是从右至左，别搞错方向拉!) 且说...9宫格的源头在河图洛书上，河图洛书也是中华文明的源头。(这个解释起来有很多要说，相信你不会希望我说太多，因为我很啰嗦) 嗯~~~这样说吧，上面的方法是我能想到的最简单直接明了的方法。 如果亲们有更好的方法算9宫，就拿出来跟大家一起分享吧 如有侵权请联系告知删除，感谢你们的配合！ 实验目的：通过visual c++进行算法编辑，准确掌握算法运行方式及流程。 通过程序实现类似九宫格的拼图效果，也叫做八方块。用最快的时间实现最后的 效果：1 2 3 4 5 6 7 8 0 实验原理：先实现一个三行三列数组，再依次比较第一个数与上下左右数值的大小，进行移动，最后实现效果图。计算出一共移动的步数和每移一步的效果。 实验内容： 程序代码如下： // 8block.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include 一、先计算天赋数与生命数（阳历出生日) 1974年7月3日 1+9+7+4+7+3=31 (3,1是天赋数) 3+1=4 (4是生命数) 1974年7月29日 1+9+7+4+7+2+9=39 (3,9是天赋数) 3+9=12 1+2=3 (3是生命数) 0是加强，比如天赋数 1，0 表示决对的天生领导人，生命数为1 那么连起来是101可查卓越数 二、按两个天赋数字及数字上的圈数查天赋表，按生命数字查生命表，按圈数查身体状况 天赋数: 1、独立、主见、天生领袖、个性较急 圈多：主观意识强，很想成功（不能指挥他） 无圈：无个人主意 2、信任别人、双重性格、在分析、色彩造型、艺术鉴赏、文学方面有优秀表现。圈多：依赖、有生活品味 无圈：不擅长合作，待他人比待自己好，容易受伤 3、创意、艺术表达力，多愁善感型 圈多：不能批评，理想坚持度高，有创意 无圈：沟通能力不好，还原改变 4、组织能力强、稳定 圈多：稳定性高，不易受影响 无圈：易受影响，改变太多 5、爱好自由、口才好、美食家、旅行家、个性开朗 圈多：主动性强，自由，不断变化，爱旅游，爱唱歌，口才好，爱吃 无圈：主动性差，要别人指导与督促，较内向，对爱情缺乏安全感 6、负责、天生有治疗别人的能力，喜欢交朋友 圈多：照顾人群、责任心强 无圈：对他人需求迟钝，要直接讲明白，不太愿意承担责任 7、好奇心，求知欲强、追求真理 圈多：好奇、质疑、专横 无圈：爱热闹，心胸开放，易相信别人 8、生意、公关、人际开发能力强，最讨厌别人懒惰 圈多：商业头脑、权力欲及公关能力强 无圈：不在乎权势，对钱没概念，不善理财 9、慈悲家、梦想家、与宗教有缘份 圈多：服务高手（不能批评） #include 第十三课搜索算法 12.0 搜索树 引例：在一个4*4的棋盘上的左下角有一个马，按照国际象棋的规则，将这个马跳到右上角。 为(4,4)。按照马的移动规则，假定当前马的位置坐标为 (x,y)，则移动方法有： （1）x’=x+1; y’=y+2 （2）x’=x+1; y’=y-2; （3）x’=x+2; y’=y+1; （4）x’=x+2; y’=y-1; （5）x’=x-1; y’=y+2; （6）x’=x-1; y’=y-2; （7）x’=x-2; y’=y+1; （8）x’=x-2; y’=y-1 图中表示：由(1,1)可以跳到(2,3)和(3,2)两个点(其它移动规则由于边界限制无法到达)；(2,3)又可以跳到(1,1)、(4,4)、(4,2)、(3,1)四个点，(3,2) 可以跳达(1,1)、(1,3)、(2,4)、(4,4)四个点，……。 搜索树：按照数据元素的产生式规则建立起来的数据元素逻辑关系。 特点：（1）数据之间的逻辑关系为一对多。 （2）每个结点数据的下一级子结点是由该结点的产生式规则生成。 （3）目标结点（答案数据）一定在搜索树中能够出现。 （4）对于数据规模较大的问题，搜索树的结点将是海量的。 （5）搜索树可能是无穷无尽的（因为很多结点回重复出现）。 12.1 搜索算法的基本原理： 从搜索树中可以看出，一个问题从起始状态，通过穷举的方式建立起搜索树后，目标状态一定能在搜索树中出现。因此，只要建立起搜索树，就可以在其中搜索到目标状态（数据、路径、位置等）。 搜索算法要解决的问题： 产生式规则：由当前状态按照问题的需求和限制，生成新的状态的方法集合。 搜索树的生成和存储：一般采用一边生成，一边搜索；存储方法有：集合、栈。 搜索的方法：按行搜索：即从上到下，逐层搜索 双向按行搜索：一边从上往下（起始状态到中间状态），一边从下往上逐 层搜索（从目标状态到中间状态），找到相同的中间状态 即可。 回朔法搜索：优先向更深层结点查找，走不通则换一条路，无法换则退回 到上一层。 搜索状态的减少：在生成搜索树时，对于已搜过的中间状态的再次出现，是否需要 再次加入到树中重新搜索。 12.2 广度优先搜索（bfs） 又称宽度优先搜索，是一种从搜索树的根结点开始，沿着树的宽度遍历树的结点。如果所有节点均被访问，则算法中止。一般用于求从起始状态到目标状态所需的最少步骤数。 算法过程： 1、首先将根结点放入队列中。 2、从队首取出一个结点，按照产生式规则逐个生成新的结点数据，对新数据： 如果如果是目标结点，则结束算法并返回结果。 如果不是目标结点，则检查它是否已在搜索树中出现过，未出现就将它作为尚未检查过的子结点加入到队列的队尾（特殊情况下，也有已出现过的结点重新入队的）。 3、重复步骤2。 4、若队列为空，表示整张图都检查过了，即目标无法达到，结束算法并返回“找 不到目标”的信息。 算法细化： 1、用哈希数组判断新生成的结点数据是否已出现过。 2、队列经常要多开一行，记录新结点的父亲（即该结点由上一层的哪个结点扩展而来）， 用于最后输出过程。 3、如数据规模过大，需要使用循环队列（后果是无法记录父亲）。 算法框架： function creat(i) begin case i of 1:creat:=按照第一产生式规则生成新状态数据； 2:creat:=按照第二产生式规则生成新状态数据； . . . end; 经典图形推理100道 第1道C 本題所有圖形均為左右對稱的 將左邊的一半去掉，剩 下的右半邊依次為數字1234 據此，可知後面為5。 第2题A 解析：去异存同 前图为:第一个图形与第二个图形重合,相同部分余下. 第二套图也如此. 第3题C 横着看三个图为一列 把外切小黑圆看成+，把内切小黑圆看成- 每一列都是图1和图2通过上面的算法和规律推出第3个图 第4题C 第一套图是逆时间转，每转90度加下面+一横 第二套图是从有小圆的90度扇形，开始逆时间旋转，每旋转一次，原有小圆的90度扇形+一个小圆，其他的90度扇形也加一个圆。 同理第3个图是：再图2的基础上再转90度，也是每转一次原有小圆扇形再+一个小圆，其他地方也同样加一个小圆。 根据以上的规律，能符合此规律的只有C项 第5题C 异色相加为黑,同色相加为白 第6题B 解析：（方法一） 把内分割线，分割出来的两个图形分别算出其比划再组成这个图行总的笔划（重合的线段算为2划）。 根据这个规律：第一套图的笔划是：6，7，8；第二套图的笔划是：9，10，11 （方法二） 看内角的个数呈规律递增；第一套图：6，7，8；第二套图：9，10，11 第7道C 第一套图的3个图的阴影部分可以组成一个全阴影图形 同理，第二套图的3个阴影部分也可以组成一个全阴影图形 第8道B 第一套是图内的3个原色不同，第二套是图内的3个原色相同，而且一一对应相似，两套图的3个图项的外框都是只有一个。 第9道B 根据第一套图和第二套图的各项图形方面不同，一一对应相似性， 第一套图：图1是左右对称，方位是左右。 图2是轴对称，方位是上下，左右；其对应相似性的图形是第二套图的图2。图3是上下对称，其对称相似性的图形是第二套图的图1 那么现在就只有第一套图的图1没有对应关系，根据其左右对称的相似性只有B 项符合，故答案为B 第10道B 若考虑把图2，图3，图4通过翻转、旋转、镜像，而组成图1，那么这样每个 第 讲 数阶幻方 导语：三阶幻方也叫“九宫格”，是我国古已有之的一种结构构造方案,欧阳洵将之引入书法练习,取其结构的平稳性和秩序感；诸葛 孔明综合八卦和九宫理念,演化成九宫八卦阵,取其结构间的依存性；中国玄学更是将之引入奇门遁甲之术,加以引 申利用."九宫格"三纵、三横,形成9个独立而又相互依存的单位,内部规整又相互依存组合.设计师从"九宫格"的 结构中获得设计灵感,以"九宫格”的设计理念,对领行国际中心的平面进行了分隔设计.中间格为电梯井、管井和楼 梯设计,8个面积大小不同的办公单位,依次排列在其周围.8个独立的小模块单位,内部平整、开放,户间相互组合,形成更大的组合开放空间.从而使整体空间结构布局更规整,为空间的自由组合提供了更大的自由度."九宫格"的创始人是:欧阳洵。这一讲就让我们一起来探究“九宫格”的算法吧。 一、九宫格算法，将1～9填入九宫格，使横看竖看斜看都相等（都等于15）。方法如下： 把上下两行、左右两列中间的数字去掉然后调换位置写到边框外面，变成上图所示，再将图形顺时针或逆时针旋转45度，再填入九宫格，便得到以下图形，就是我们所要的答案。 拓展平台 1、 将11,13,15,17,19,21,23,25,27填入下面的表格中，是表格每 横行、每竖行、每斜行的和都相等。 2、用一组数据构造一个三阶幻方，是它的幻和等于48？ 二、四四格算法，使横看竖看斜看均为34： 1、 先绘制四四格如下，并填写数据。 2、将外四角对角交换如下：（即1换16、4换13） 3、将内四角对角交换如下，完成转换：（即6换11、7换10） java实现九宫图： 要求如下： 要求是横排，竖排，还有大九宫格中的9个《小九宫格》都是1-9各不相同。如图，图上已经给了几个数了。 程序如下： import java.util.Scanner; class jiugongjiuge { public static void main(String[] args) { int[][] g = new int[9][9]; boolean[][] bol = new boolean[9][10];//判断随机数是不是位0的数组 for(int i=0; i<9; i++) { int k=0; for(int j=1;j<10;j++) { bol[i][j]=false; //第0个往后的都是0 bol[i][0]=true; //第0个是1 } for (int j = 0; j < 9; ) double a = Math.random() * 10; a = Math.ceil(a); int randomNum = new Double(a).intValue()%10;//随机产生的数字除以10取余数 if(bol[i][randomNum])//判断产生的随机数不是0 continue; //跳出这次的循环进行下次循环 g[i][k]=randomNum; k++; bol[i][randomNum]= true; j++; } flag:for(int n=0; n 用.Net实现九宫格移动算法 说明：在3*3的格子里，假设一个格子为空（在程序里是用0代表），其他格子可以移动到这个格子上，有多少种可能？答案是9的阶乘除以2=181440种，以下为程序实现，输出到d:\GridNine.txt文件中。程序共两个类Program和Mygrid。以下为代码： Program： --------------------------------------------------------------------------------------------using System; using System.Collections.Generic; using System.Windows.Forms; using System.IO; namespace WindowsApplication1 { static class Program { static int gen = 0; /// importitertools importnumpy as np nums = [x for x in range(1,10)] #把1到9这10个数组成的数组赋值给nums sequence_3nums = [p for p in itertools.permutations(nums,3) if sum(p)==15] #从nums中一次选出一个数赋值给p，最终得到sequence_3nums是一个1*3的数组，且满足三个数之和为15 for row1_1,row1_2,row1_3 in sequence_3nums: #从sequence_3nums中选择一组赋值给row1_1,row1_2,row1_3 for row2_1,row2_2,row2_3 in sequence_3nums: for row3_1,row3_2,row3_3 in sequence_3nums: if row1_1+row2_1+row3_1==15 and row1_2+row2_2+row3_2==15 \ and row1_3+row2_3+row3_3==15 and row1_1+row2_2+row3_3==15 \ and row3_1+row2_2+row1_3==15 : #筛选出每一行，每一列，对角线元素之和为15的矩阵 if len(set([row1_1,row1_2,row1_3])&set([row2_1,row2_2,row2_3]))==0 \ and len(set([row1_1,row1_2,row1_3])&set([row3_1,row3_2,row3_3]))==0 \ and len(set([row2_1,row2_2,row2_3])&set([row3_1,row3_2,row3_3]))==0: #筛选出每一个九宫格中的数字均不相同的矩阵 九宫格拼图游戏设计文档 一、综合设计目的、条件、任务和内容要求： 1．设计目的 《Windows程序设计》是计算机科学与技术专业本科生的一门学科基础课程。Windows程序以图形用户界面（GUI）给用户提供各种功能，在各行各业有着广泛的应用。基于MFC的Windows程序设计是进行Win32程序设计的一种主流方法。 本课程主要介绍Windows程序设计的思想和方法，以及MFC的常见应用。本课程综合应用算法与程序设计、面向对象程序设计、数据结构、操作系统、数据库系统原理等课程的知识和方法，面向实际应用和开发，以培养、提高学生的程序设计能力和软件工程能力为目的。通过课程教学、上机实践、综合设计等教学环节，使学生逐步掌握Windows程序设计和MFC的常见应用，并能在实践中熟练应用所掌握的工具和方法解决实际问题。 2．实施方式 本课程重在训练学生的综合设计能力和项目开发应用能力，并强调学生的上机实践能力。按照常规考试方式，不能体现本课程“以理论为基础，侧重实践和应用”的特点，也不能考查学生理解本课程知识的程度以及所培养具备的MFC程序设计应用能力。 3．任务和要求： 针对某一综合应用项目，完成如下任务： （1）简要的需求分析 （2）规划系统主要功能及其结构。 （3）完成各项系统功能的设计。 （4）形成项目文档和开发报告。 4．工具与环境： 设计工具：Visual Studio 二、进度安排： 第1周：基础知识串联复习 第2周：撰写设计报告，并按时递交。 第3周：实现系统各模块功能功能 第一部分设计方案论述 2.1项目方案论述 2.1.1具体论述 1.CMenu* GetSubMenu(int nPos) 若弹出菜单位于指定的位置，则返回CMenu 对象的指针，其中CMenu对象要包含弹出菜单的句柄；否则返回NULL。如果CMenu 对象不存在，那么将创建临时CMenu对象，但返回的CMenu指针不应被存储。nPos指定包含在菜单中的弹出菜单的位置。对于第一个菜单项，开始位置值为0。 2.BOOL AppendMenu(UINT nFlags, UINT nIDNewItem=0, LPCTSTR lpszNewItem= NULL) 在末尾添加一项，若nFlags为MF_SEPARATOR表示增加一个分隔条，这样其他两个参数将会被忽略；若nFlag为MF_STRING表示添加一个菜单项。nIDNewItem为该菜单的ID命令值；若nIDNewItem为MF_POPUP表示添加一个弹出菜单项，这时nIDNewItem为另一菜单的句柄HMENU。lpszNewItem为菜单文字说明。 3.BOOL InsertMenu(UINT nPosition，UINT nFlags ，UINT nIDNewItem = 0， LPCTSTR lpszNewItem = NULL) 用于在指定位置插入一菜单，变量nPosition指定插入位置。如果nFlags 包含MF_BYPOSITION 则表明插入在nPosition 位置，如果包含MF_BYCOMMAND表示插入在ID为nPosition的菜单处。 4.BOOL ModifyMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem=0 ， LPCTSTR lpszNewItem = NULL) 用于修改某一位置的菜单，如果nFlags包含MF_BYPOSITION， 则表明修改nPosition位置的菜单，如果包含MF_BYCOMMAND表示修改ID为 nPosition处的菜单。 5.BOOL RemoveMenu(UINT nPosition, UINT nFlags) 用于删除某一位置的菜单。如果 nFlags 包含MF_BYPOSITION 则表明删除nPosition 位置的菜单，如果包含MF_BYCOMMAND表示删除ID为nPosition处的菜单。 6.BOOL AppendMenu(UINT nFlags, UINT nIDNewItem, const CBitmap* pBmp) 和BOOL InsertMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem, const CBitmap* pBmp)可以添加位图菜单，但这样的菜单在选中时是反色显示，并不美观。 7.UINT CheckMenuItem(UINT nIDCheckItem, UINT nCheck) 返回菜单项以前的状态： MF_CHECKED 或MF_UNCHECKED 。如果该菜单项不存在，那么将返回0xFFFFFFFF。nIDCheckItem指定由nCheck确定的将要选择的菜单项。nCheck指定是否选中菜单项，并决定菜单中各菜单项的位置。参数nCheck可以是MF_CHECKED或MF_UNCHECKED与MF_BYPOSITION或MF_BYCOM MAND的组合。这些标志可通过使用位与运算进行组合。其中MF_CHECKED与MF_UNCHECKED用来进行状态转换，在菜单项之前放置默认的选中标记。 简而言之，调用一系列函数将游戏启动（初始化变量）、选择位图、加载位图、游 九宫格的启发式搜索 班级：计算机一班 姓名：覃荣锦 学号：1240023 目录 一、实验目的 (3) 二、实验语言环境 (3) 三、实现设计 (3) 1. 状态表示： (3) 2. 算法介绍： (3) 1) 广度优先搜索： (3) 2) 深度优先搜索： (4) 3. 初始化节点以及判断目标节点 (5) 4. 拓展节点 (6) 5. 搜索算法 (7) 四、程序全部代码 (8) 五、分析总结 (15) 1. 数据结构分析 (15) 2. 拓展方法分析 (15) 3. 搜索算法分析 (15) 六、运行结果 (16) 七、遇见的问题以及解决方法 (16) 一、实验目的 加深对局部择优搜索以及全局择优搜索的熟悉程度。 了解局部择优搜索以及全局择优搜索的区别。 二、实验语言环境 系统：微软Window7系统 开发工具：visual c/c++ 6.0 语言：c语言 三、实现设计 1.状态表示： 九宫格状态以一组一维数组表示。1~8分别表示8个对应的数字，0表示空格，数据结构如下： Typedef struct { Int data[9]; }Data; 九宫格节点为以线性表表示的树的节点，因此需要加入指向该节点父母的指针，在这里用下标表示，同时由于不同节点有不同的估值，因此需要加入表示其值变量。完整的数据结构如下： typedef struct { int data[9]; int parent; int value; } Data; 2.算法介绍： 1)局部择优搜索： 第一步：把初始节点S0放入open表。 第二步：如果open表为空，则问题无解，退出。 人工智能原理与方法 A*算法实现八数码搜索问题 模式识别与智能系统 SY1003113 游遵文 题目：编程实现8数码问题 初始状态： 3 8 2 1 5 7 6 4 目标状态： 1 2 3 8 4 7 6 5 要求：1、报告：给出状态表示，编码规则，搜索算法A*，简单程序说明，最优路径。 2、调通的程序（语言不限） 一、状态表示 用一个3×3的数组来表示状态，数组中的各个元素对应状态位置的数字。 其中空格用0表示。 二、编码规则 在程序实现过程中，只有移动0的位置，即可生成新的节点。 规则库 设数组中0的位置为a[i][j]，其中0≤i≤2，0≤j≤2。 R1：if(i≥1) then 上移 R1：if(i≤1) then 下移 R1：if(j≥1) then 左移 R1：if(j≤1) then 右移 三、搜索算法A* 用于度量节点的“希望”的量度f(n)，即用来衡量到达目标节点的路径的可能性大小。 A算法： 基本思想：定义一个评价函数，对当前的搜索状态进行评估，找出一个最有希望的节点进行扩展：f(n) = g(n) + h(n)，n为被评价节点 g*(n)：从s到n的最优路径的实际代价 h*(n)：从n到g的最优路径的实际代价 f*(n)=g*(n)+h*(n)：从s经过n到g的最优路径的实际代价 g(n)、h(n)、f(n)分别是g*(n)、h*(n)、f*(n)的估计值 g (n)通常为从S到到n这段路径的实际代价，则有g (n) ≥g*(n) h (n):是从节点n到目标节点Sg的最优路径的估计代价. 它的选择依赖于有关问题领域的启发信息，叫做启发函数 A算法：在图搜索的一般算法中，在搜索的每一步都利用估价函数f(n)=g(n)+h(n)对Open表中的节点进行排序表中的节点进行排序, 找出一个最有希望的节点作为下一次扩展的节点。 在A算法中，如果满足条件：h(n)≤h*(n)，则A算法称为A*算法。 在本算法中，为实现八数码的搜索问题，定义估价函数为：f(n)=g(n)+h(n)，其中g（n）表示节点n在搜索树中的深度； h（n）表示节点n的各个数码到目标位置的曼哈顿距离和。 四、程序说明 1、算法实现的步骤： （1）把初始节点S0放入Open表中，置S0的代价g(S0)=0； （2）如果Open表为空，则问题无解，失败退出； （3）把Open表的第一个节点取出放入Closed表，并记该节点为n （4）考察节点n是否为目标节点。若是，则找到了问题的解，成功退出；（5）若节点n不可扩展，则转第（2）步； （6）扩展节点n，生成其子节点ni, （其中i=1,2,3,……），将这些子节点放入Open表中，并为每一个子节点设置指向父节点的指针；按公式g（ni）=g(n)＋c(n，ni)（i=1，2，…）计算Open表中的各子节点的代价，并根据各节点的代价对Open表中的全部节点按照从小到大顺序重新进行排序；然后转第（2）步。 2、思路 通过代价函数对Open表中的节点进行排序，代价小的先扩展。 九宫格的解题过程 第1步首先计算每行数字之和。 1－9九个数字之和：1＋2＋3＋4＋5＋6＋7＋8＋9＝45 九宫格共有三行，并且每行的数字之和相等，因此45/3＝15，即每行数字之和为15。 第2步计算中间格的数字。 考虑第2行，第2列，和2条对角线的数字之和。它们的总和为 15/4 ＝ 60。在它们的总和中，中间格子的数字出现了4次，其它位置格子的数字都出现了而且仅出现了1次。 所以，它们的总和＝（4×中间格子的数字）＋（其它8个数字） ＝（3×中间格子的数字）＋（1－9九个数字之和） 因此， 60＝3×中间格子的数字＋45，中间格子的数字等于5 第3步，奇数不能出现在4个角上的格子里。 比如，如果数字9出现在角上的格子里，那么为了保证9所在行或所在列的数字和为15，必须需要4个数字，两两之和必须为6。1，2，3，4，6，7，8中，只有2和4组成和为6的数字对，找到第2个和为6的数字对是不可能的。因此，数字9不能出现在4个角上的格子里。 同样道理，1，3，7也不能出现在4个角上的格子里。 第4步，2，4，6，8必须填在4个角上的格子里，并且保证对角线数字和为15。 第5步，将1，3，7，9填入相应的格子里就完成了九宫格填数字任务，注意和为15的条件。 完成了填九宫格的任务后，我们进一步考虑，如果上面九宫格内所有数字都加数字1会发生什么呢即可不可以用数字2，3，4，5，6，7，8，9，10填九宫格，得到每一行，每一列，每一对角线的三个数字之和都相等的新九宫格呢。 显而易见，上面九宫格每行每列每对角线数字之和为18，奇数3，5，7，9处在4个角上的格子里，中间数6处在中间的格子里。 从1－9和2－10各九个数字所填充的九宫格可以得出下列规律： 1）九个数字是由9个相连的整数构成的。 2）九个数字中正中间的数字填在九宫格的中间格子里。1－9中的5，2-10中的6等。 3）每行每列的数字和等于中间数字的三倍。比如15＝5′3和18=6′3。 4）第2，4，6，8位的数字填充到4个角上的格子里。如2，3，4，5，6，7，8，9，10中的3，5，7，9和1，2，3，4，5，6，7，8，9中的2，4，6，8。 问题1：已知9个相连的整数填充的九宫格其每行数字和为45，求这九个数字。 浅谈九宫图的算法及规律 骆光明 中文摘要：九宫图博大精深，不仅显示出中国文化渊源流长，而且中国古代哲学，算术，治理国家（大禹治水）等方面运用非常广泛。本文主要对九宫图最基本的算法和规律研究，主要来源于九宫图练习题的解法，并作了一些规律探讨。 中文关键词：九宫图的算法 方程求解 规律 一般方程形式 正文 一、九宫图已知三个数求另外的数。 可以用设三个数的和为一个未知数的方法，把其余的数表示出来，然后找相等的关系，进而求得未知数及剩下所有的数。下面来看一个例子。 如图，a ，b ，c ，d ，e ，f ，均为有理数，图中各行、各列、两条对角线上三个数之和都相等。试求 f e d c b a ef cd ab +++++++。 分析：要求得这个代数式的值，首先求出a ，b ，c ，d ，e ，f 各数的值。 解：设图中各行、各列、两条对角线上三个数之和为x ，那么 f =x-9 e =x-8 d =x-(x-9)-6=3 b =x-10 c=x-(x-8)-3=5 a=x-(x-9)-5=x-(x-10)-6=4 所以，x=a+d+2=4+3+2=9 那么，a=4 b=-1 c=5 d=3 e=1 f=0 如图： 可以应用这个办法求得下面两个九宫图的其他数值。 1. a b 6 c d e f 7 2 4 x-10 6 5 3 x-8 x-9 7 2 4 -1 6 5 3 1 0 7 2 （8） （15） （10） 13 （11） 9 x 由x-25+x-22+x-19=x ，解得x=33 2. 由9+x-24+x-15=x ，解得x=30 二、那么，在这九宫图中，有什么规律可循呢？体现了中国古代人什么样的智慧呢？ 把上面三个九宫图写在一起，看看里面有些数字规律。 三个数的和为9 三个数的和为33 三个数的和为30 规律一：各行、各列及对角线三个数的和与中间的数字（以下简称中心数）的关系：和是中心数的3倍。 规律二： 12 （7） （14） x-25 10 13 x-22 9 12 x-19 5 （16） （9） 14 10 （6） （11） （4） （15） 5 9 14 10 X-24 X-19 X-15 4 -1 6 5 3 1 0 7 2 8 15 10 13 11 9 12 7 14 5 16 9 14 10 6 11 4 15 4 -1 6 5 1 3 package Lesson9; import java.util.Scanner; public class Hannuo { /** * @param args */ public static void main(String[] args) { char a = 'A'; char b = 'B'; char c = 'C'; System.out.println("请输入要移动几个盘子："); Scanner sc = new Scanner(System.in); int num = sc.nextInt(); hannuo(num,a,b,c); } public static void hannuo(int n,char a,char b,char c){ if(n==1){ System.out.printf("%d:%s->%s",n,a,c); }else{ hannuo(n-1,a,c,b); System.out.printf("%d:%s->%s",n,a,c); hannuo(n-1,b,a,c); } } } package Lesson9; public class Nine { /** * @param args */ public static void main(String[] args) { int[][] arr = new int[3][3]; for(int i1= 1;i1<=9;i1++){ arr[0][0] = i1; for(int i2= 1;i2<=9;i2++){ arr[0][1] = i2; for(int i3= 1;i3<=9;i3++){ arr[0][2] = i3; for(int i4= 1;i4<=9;i4++){ arr[1][0] = i4; for(int i5= 1;i5<=9;i5++){ arr[1][1] = i5; for(int i6= 1;i6<=9;i6++){ arr[1][2] = i6; for(int i7= 1;i7<=9;i7++){ arr[2][0] = i7; for(int i8= 1;i8<=9;i8++){ arr[2][1] = i8; for(int i9= 1;i9<=9;i9++){ arr[2][2] = i9; if( (arr[0][0]+arr[0][1]+arr[0][2]==15)&& (arr[1][0]+arr[1][1]+arr[1][2]==15)&& (arr[2][0]+arr[2][1]+arr[2][2]==15)&&小学数独精通技巧
九宫格算法攻略
九宫格实现算法
生命密码算法大全[1]
数据结构课程设计之九宫格
算法与数据结构讲义三(搜索算法)
2011年公务员考试经典图形推理100道 九宫格专题(整理版)
九宫格算法
java实现九宫图--九宫格的程序
九宫格移动算法实现
Python编写九宫格程序
九宫格拼图游戏
九宫格的启发式搜索
人工智能A算法九宫格报告
九宫格的解题过程
浅谈九宫图的算法和规律
java汉诺贪心九宫格算法集合