#include "Stdio.h"
#include "Conio.h"
#include "stdlib.h"
#include "math.h"
void Copy_node(struct node *p1,struct node *p2);
void Calculate_f(int deepth,struct node *p);
void Add_to_open(struct node *p);
void Add_to_closed(struct node *p);
void Remove_p(struct node *name,struct node *p);
int Test_A_B(struct node *p1,struct node *p2);
struct node * Search_A(struct node *name,struct node *temp);
void Print_result(struct node *p);
struct node // 定义8数码的节点状态
{
int s[3][3]; //当前8数码的状态
int i_0; //当前空格所在行号
int j_0; //当前空格所在列号
int f; //当前代价值
int d; //当前节点深度
int h; //启发信息，采用数码"不在位"距离和
struct node *father; //指向解路径上该节点的父节点
struct node *next; //指向所在open或closed表中的下一个元素
} ;
struct node s_0={{2,8,3,1,6,4,7,0,5},2,1,0,0,0,NULL,NULL}; //定义初始状态
struct node s_g={{1,2,3,8,0,4,7,6,5},1,1,0,0,0,NULL,NULL}; //定义目标状态
struct node *open=NULL; //建立open表指针struct node *closed=NULL; //建立closed表指针int sum_node=0; //用于记录扩展节点总数
//***********************************************************
//********************** **********************
//********************** 主函数开始**********************
//********************** **********************
//***********************************************************
void main()
{
int bingo=0; //定义查找成功标志，bingo=1，成功
struct node s; //定义头结点s
struct node *target,*n,*ls,*temp,*same; //定义结构体指针
Copy_node(&s_0,&s); //复制初始状s_0态给头结点s Calculate_f(0,&s); //计算头结点的代价值
Add_to_open(&s); //将头结点s放入open表
while(open!=NULL) //只要open表不为空，进行以下循环
{
n=open; //n指向open表中当前要扩展的元素
ls=open->next;
Add_to_closed(n);
open=ls; //将n指向的节点放入closed表中
if(Test_A_B(n,&s_g)) //当前n指向节点为目标时，跳出程序结束；否则，继续下面的步骤
{
bingo=1;
break;
}
else
if(n->j_0>=1) //空格所在列号不小于1,可左移
{
temp=n->father;
if(temp!=NULL&&temp->i_0==n->i_0&&temp->j_0-1==n->j_0) //新节点与其祖父节点相同
;
else //新节点与其祖父节点不同，或其父节点为起始节点
{
temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间
Copy_node(n,temp); //拷贝n指向的节点状态
temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0][temp->j_0-1]; //空格左移
temp->s[temp->i_0][temp->j_0-1]=0;
temp->j_0--;
temp->d++;
Calculate_f(temp->d,temp); //修改新节点的代价值
temp->father=n; //新节点指向其父节点
if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点
{
if(temp->f
{
Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点
Add_to_open(temp);
sum_node++;
}
else;
}
else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点
{
if(temp->f
{
Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点
Add_to_open(temp);
sum_node++;
}
else ;
}
else //新节点为完全不同的新节点，加入open表
{
Add_to_open(temp);
sum_node++;
}
}
}//end左移
if(n->j_0<=1) //空格所在列号不大于1,可右移
{
temp=n->father;
if(temp!=NULL&&temp->i_0==n->i_0&&temp->j_0+1==n->j_0) //新节点与其祖父节点相同
;
else //新节点与其祖父节点不同，或其父节点为起始节点
{
temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间
Copy_node(n,temp); //拷贝p指向的节点状态
temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0][temp->j_0+1]; //空格右移
temp->s[temp->i_0][temp->j_0+1]=0;
temp->j_0++;
temp->d++;
Calculate_f(temp->d,temp); //修改新节点的代价值
temp->father=n; //新节点指向其父节点
if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点
{
if(temp->f
代价小，加入open表
{
Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点
Add_to_open(temp);
sum_node++;
}
else;
}
else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点
{
if(temp->f
{
Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点
Add_to_open(temp);
sum_node++;
}
else ;
}
else //新节点为完全不同的新节点，加入open表
{
Add_to_open(temp);
sum_node++;
}
}
}//end右移
if(n->i_0>=1) //空格所在列号不小于1,上移
{
temp=n->father;
if(temp!=NULL&&temp->i_0==n->i_0-1&&temp->j_0==n->j_0) //新节点与其祖父节点相同
;
else //新节点与其祖父节点不同，或其父节点为起始节点
{
temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间
Copy_node(n,temp); //拷贝p指向的节点状态
temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0-1][temp->j_0]; //空格上移
temp->s[temp->i_0-1][temp->j_0]=0;
temp->i_0--;
temp->d++;
Calculate_f(temp->d,temp); //修改新节点的代价值
temp->father=n; //新节点指向其父节点
if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点
{
if(temp->f
{
Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点
Add_to_open(temp);
sum_node++;
}
else;
}
else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点
{
if(temp->f
{
Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点
Add_to_open(temp);
sum_node++;
}
else ;
}
else //新节点为完全不同的新节点，加入open表
{
Add_to_open(temp);
sum_node++;
}
}
}//end上移
if(n->i_0<=1) //空格所在列号不大于1,下移
{
temp=n->father;
if(temp!=NULL&&temp->i_0==n->i_0+1&&temp->j_0==n->j_0) //新节点与其祖父节点相同
;
else //新节点与其祖父节点不同，或其父节点为起始节点
{
temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间
Copy_node(n,temp); //拷贝p指向的节点状态
temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0+1][temp->j_0]; //空格下移
temp->s[temp->i_0+1][temp->j_0]=0;
temp->i_0++;
temp->d++;
Calculate_f(temp->d,temp); //修改新节点的代价值
temp->father=n; //新节点指向其父节点
if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点
{
if(temp->f
{
Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点
Add_to_open(temp);
sum_node++;
}
else;
}
else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点
{
if(temp->f
{
Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点
Add_to_open(temp);
sum_node++;
}
else ;
}
else //新节点为完全不同的新节点，加入open表
{
Add_to_open(temp);
sum_node++;
}
}
}//end下移
}
if(bingo=1) Print_result(n); //输出解路径
else printf("问题求解失败！");
}//主函数结束
//*************************************************************************
//********************** **********************
//********************** 计算某个节点状态的代价值**********************
//********************** **********************
//*************************************************************************
void Calculate_f(int deepth,struct node *p)
{
int i,j,temp;
temp=0;
for(i=0;i<=2;i++) //计算所有"不在位"数码的距离和
{
for(j=0;j<=2;j++)
{
if((p->s[i][j])!=(s_g.s[i][j]))
temp++;
}
}
p->h=temp;
p->f=deepth+p->h;
}
//*************************************************************************
//********************** **********************
//********************** 添加p指向的节点到open表中********************** //********************** **********************
//*************************************************************************
void Add_to_open(struct node *p)
{
struct node *p1,*p2;
p1=open; //初始时p1指向open表首部
p2=NULL;
if(open==NULL) //open表为空时，待插入节点即为open表第一个元素，open指向该元素
{
p->next=NULL;
open=p;
}
else //open表不为空时，添加待插入节点，并保证open表代价递增
的排序
{
while(p1!=NULL&&p->f>p1->f)
{
p2=p1; //p2始终指向p1指向的前一个元素
p1=p1->next;
}
if(p2==NULL) //待插入节点为当前open表最小
{
p->next=open;
open=p;
}
else if(p1==NULL) //待插入节点为当前open表最大
{
p->next=NULL;
p2->next=p;
}
else //待插入节点介于p2、p1之间
{
p2->next=p;
p->next=p1;
}
}
}
//*************************************************************************** //********************** ********************** //********************** 添加p指向的节点到closed表中********************** //********************** ********************** //***************************************************************************
void Add_to_closed(struct node *p)
{
if(closed==NULL) //closed表为空时，p指向节点为closed表第一个元素，closed指向该元素
{
p->next=NULL;
closed=p;
}
else //closed表不为空时，直接放到closed表首部
{
p->next=closed;
closed=p;
}
}
//***************************************************************************** *********************
//**********************
**********************
//********************** 在open表或closed表中搜索和temp指向的节点相同的节点**********************
//**********************
**********************
//***************************************************************************** *********************
struct node * Search_A(struct node *name,struct node *temp)
{
struct node *p1;
p1=name; //p1指向open表或closed表
while(p1!=NULL)
{
if(Test_A_B(p1,temp)) //找到相同的节点，返回该节点地址
return p1;
else
p1=p1->next;
}
return NULL;
}
//***************************************************************************** ******************
//**********************
**********************
//********************** 判断两个节点状态是否相同，相同则返回1，否则返回0 **********************
//**********************
**********************
//***************************************************************************** ******************
int Test_A_B(struct node *p1,struct node *p2)
{
int i,j,flag;
flag=1;
for(i=0;i<=2;i++)
for(j=0;j<=2;j++)
{
if((p2->s[i][j])!=(p1->s[i][j])) { flag=0; return flag; }
else ;
}
return flag;
}
//***************************************************************************** *
//**********************
**********************
//********************** 从open表或closed表删除指定节点**********************
//**********************
**********************
//***************************************************************************** *
void Remove_p(struct node *name,struct node *p)
{
struct node *p1,*p2;
p1=NULL;
p2=NULL;
if(name==NULL) //如果name指向的链表为空，则不需要进行删除
return;
else if(Test_A_B(name,p)&&name->f==p->f) //指定节点为name指向的链表的第一个元素
{
open=name->next;
name->next=NULL;
return;
}
else
{
p2=name;
while(p1)
{
if(Test_A_B(p1,p)&&p1->f==p->f) //找到指定节点
{
p2->next=p1->next;
return;
}
else
{
p2=p1; //p2始终指向p1指向的前一个元素
p1=p1->next;
}
}
return;
}
}
//***************************************************************************** *********
//**********************
**********************
//********************** 将p1指向的节点状态拷贝到p2指向的节点中**********************
//**********************
**********************
//***************************************************************************** *********
void Copy_node(struct node *p1,struct node *p2)
{
int i,j;
for(i=0;i<=2;i++)
{
for(j=0;j<=2;j++)
{ p2->s[i][j]=p1->s[i][j]; }
}
p2->i_0=p1->i_0;
p2->j_0=p1->j_0;
p2->f=p1->f;
p2->d=p1->d;
p2->h=p1->h;
p2->father=p1->father;
}
//*********************************************************** //********************** ********************** //********************** 输出结果********************** //********************** ********************** //***********************************************************
void Print_result(struct node *p)
{
struct node *path[100];
struct node *temp,*temp_father;
int i,j,k;
for(i=0;i<=99;i++) //初始化路径指针数组path[i]=0;
temp=p;
printf("总共扩展%d 个节点\n",sum_node);
printf("总共扩展%d 层\n",temp->d);
printf("解路径如下：\n");
for(i=p->d;i>=0;i--) //存储解路径上各节点的地址{
path[i]=temp;
temp=temp->father;
}
for(k=0;k<=p->d;k++) //输出解路径
{
temp=path[k]; //建立节点指点指针
printf("第%d步",temp->d);
if(k-1>=0) //输出移动策略
{
temp_father=path[k-1];
if(temp->i_0
if(temp->i_0>temp_father->i_0) printf("->下移\n");
if(temp->j_0
if(temp->j_0>temp_father->j_0) printf("->右移\n");
}
else
printf("\n");
printf("当前节点状态为：\n");
for(i=0;i<=2;i++)
{
for(j=0;j<=2;j++)
{
printf("%d ",temp->s[i][j]);
}
printf("\n");
}
printf("\n");
}
}
A*算法实验报告 实验目的 1．熟悉和掌握启发式搜索的定义、估价函数和算法过程 2. 学会利用A*算法求解N数码难题 3. 理解求解流程和搜索顺序 实验原理 A*算法是一种有序搜索算法，其特点在于对估价函数的定义上。对于一般的有序搜索，总是选择f值最小的节点作为扩展节点。因此，f是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点n的估价函数值为两个分量：从起始节点到节点n的代价以及从节点n到达目标节点的代价。 实验条件 1.Window NT/xp/7及以上的操作系统 2.内存在512M以上 3.CPU在奔腾II以上 实验内容 1.分别以8数码和15数码为例实际求解A*算法 2.画出A*算法求解框图 3.分析估价函数对搜索算法的影响 4.分析A*算法的特点 实验分析 1. A*算法基本步骤 1）生成一个只包含开始节点n0的搜索图G，把n0放在一个叫OPEN的列表上。
2）生成一个列表CLOSED，它的初始值为空。 3）如果OPEN表为空，则失败退出。 4）选择OPEN上的第一个节点，把它从OPEN中移入CLPSED，称该节点为n。 5）如果n是目标节点，顺着G中，从n到n0的指针找到一条路径，获得解决方案，成功退出（该指针定义了一个搜索树，在第7步建立）。 6）扩展节点n，生成其后继结点集M，在G中，n的祖先不能在M中。在G中安置M的成员，使他们成为n的后继。 7）从M的每一个不在G中的成员建立一个指向n的指针（例如，既不在OPEN 中，也不在CLOSED中）。把M1的这些成员加到OPEN中。对M的每一个已在OPEN中或CLOSED中的成员m，如果到目前为止找到的到达m的最好路径通过n，就把它的指针指向n。对已在CLOSED中的M的每一个成员，重定向它在G中的每一个后继，以使它们顺着到目前为止发现的最好路径指向它们的祖先。 8）按递增f*值，重排OPEN（相同最小f*值可根据搜索树中的最深节点来解决）。 9）返回第3步。 在第7步中，如果搜索过程发现一条路径到达一个节点的代价比现存的路径代价低，就要重定向指向该节点的指针。已经在CLOSED中的节点子孙的重定向保存了后面的搜索结果，但是可能需要指数级的计算代价。 实验步骤 算法流程图
实验报告 一、实验问题 八数码问题求解 二、实验软件 VC6.0 编程语言或其它编程语言 三、实验目的 1. 熟悉人工智能系统中的问题求解过程； 2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用； 3. 熟悉对八数码问题的建模、求解及编程语言的应用。 四、实验数据及步骤 （一、）实验内容 八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。 2 8 3 1 2 3 1 4 8 4 7 6 5 7 6 5 (a) 初始状态(b) 目标状态 图1 八数码问题示意图 （二、）基本数据结构分析和实现 1.结点状态 我采用了struct Node数据类型 typedef struct _Node{
int digit[ROW][COL]; int dist; // distance between one state and the destination一 个表和目的表的距离 int dep; // the depth of node深度 // So the comment function = dist + dep.估价函数值 int index; // point to the location of parent父节点的位置 } Node; 2.发生器函数 定义的发生器函数由以下的四种操作组成： (1)将当前状态的空格上移 Node node_up; Assign(node_up, index);//向上扩展的节点 int dist_up = MAXDISTANCE; (2)将当前状态的空格下移 Node node_down; Assign(node_down, index);//向下扩展的节点 int dist_down = MAXDISTANCE; (3)将当前状态的空格左移 Node node_left; Assign(node_left, index);//向左扩展的节点 int dist_left = MAXDISTANCE; (4)将当前状态的空格右移 Node node_right; Assign(node_right, index);//向右扩展的节点 int dist_right = MAXDISTANCE; 通过定义结点状态和发生器函数，就解决了8数码问题的隐式图的生成问题。接下来就是搜索了。 3.图的搜索策略 经过分析，8数码问题中可采用的搜速策略共有：1.广度优先搜索、2.深度优先搜索、2.有界深度优先搜索、4.最好优先搜索、5.局部择优搜索，一共五种。其中，广度优先搜索法是可采纳的，有界深度优先搜索法是不完备的，最好优先和局部择优搜索法是启发式搜索法。 实验时,采用了广度(宽度)优先搜索来实现。 （三、）广度(宽度)优先搜索原理 1. 状态空间盲目搜索——宽度优先搜索 其基本思想是，从初始节点开始，向下逐层对节点进形依次扩展，并考察它是否为目标节点，再对下层节点进行扩展（或搜索）之前，必须完成对当层的所有节点的扩展。再搜索过程中，未扩展节点表OPEN中的节点排序准则是：先进入的节点排在前面，后进入的节点排在后面。其搜索过程如图（1）所示。
用A*算法解决八数码问题 一、 题目：八数码问题也称为九宫问题。在3×3的棋盘，有八个棋子，每个 棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有 一个空格，与空格相邻的棋子可以移到空格中。要解决的问题是：任意给 出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动 棋子步数最少的移动步骤。 二、 问题的搜索形式描述 状态：状态描述了8个棋子和空位在棋盘的9个方格上的分布。 初始状态：任何状态都可以被指定为初始状态。 操作符：用来产生4个行动（上下左右移动）。 目标测试：用来检测状态是否能匹配上图的目标布局。 路径费用函数：每一步的费用为1，因此整个路径的费用是路径中的步数。 现在任意给定一个初始状态，要求找到一种搜索策略，用尽可能少的步数 得到上图的目标状态算法介绍 三、 解决方案介绍 1.A*算法的一般介绍 A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。对于 几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价值，即 ()()()()()()**f g n sqrt dx nx dx nx dy ny dy ny =+--+--； 这样估价函数f 在g 值一定的情况下，会或多或少的受估价值h 的制约，节点距目标点近，h 值小，f 值相对就小，能保证最短路的搜索向终点的 方向进行。明显优于盲目搜索策略。
A star算法在静态路网中的应用 2.算法伪代码 创建两个表，OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。算起点的估价值，将起点放入OPEN表。 while(OPEN!=NULL) { 从OPEN表中取估价值f最小的节点n; if(n节点==目标节点) {break;} for(当前节点n 的每个子节点X) { 算X的估价值; if(X in OPEN) { if( X的估价值小于OPEN表的估价值 ) {把n设置为X的父亲; 更新OPEN表中的估价值; //取最小路径的估价值} } if(X inCLOSE) { if( X的估价值小于CLOSE表的估价值 ) {把n设置为X的父亲; 更新CLOSE表中的估价值; 把X节点放入OPEN //取最小路径的估价值} } if(X not inboth) {把n设置为X的父亲; 求X的估价值; 并将X插入OPEN表中; //还没有排序}
基于人工智能的状态空间搜索策略研究 ——八数码问题求解 （一）实验软件 TC2.0 或VC6.0编程语言或其它编程语言 （二）实验目的 1. 熟悉人工智能系统中的问题求解过程； 2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用； 3. 熟悉对八数码问题的建模、求解及编程语言的应用。 （三）需要的预备知识 1. 熟悉TC 2.0或VC6.0 编程语言或者其它编程语言； 2. 熟悉状态空间的宽度优先搜索、深度优先搜索和启发式搜索算法； 3. 熟悉计算机语言对常用数据结构如链表、队列等的描述应用； 4. 熟悉计算机常用人机接口设计。 （四）实验数据及步骤 1. 实验内容 八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。 图1 八数码问题示意图 请任选一种盲目搜索算法（深度优先搜索或宽度优先搜索）或任选一种启发式搜索方法（A 算法或A* 算法）编程求解八数码问题（初始状态任选），并对实验结果进行分析，得出合理的结论。 2. 实验步骤 （1）分析算法基本原理和基本流程； 程序采用宽度优先搜索算法，基本流程如下：
（2）确定对问题描述的基本数据结构，如Open表和Closed表等；
（3）编写算符运算、目标比较等函数； （4）编写输入、输出接口； （5）全部模块联调； （6）撰写实验报告。 （五）实验报告要求 所撰写的实验报告必须包含以下内容： 1. 算法基本原理和流程框图； 2. 基本数据结构分析和实现； 3. 编写程序的各个子模块，按模块编写文档，含每个模块的建立时间、功能、输入输出参数意义和与其它模块联系等； 4. 程序运行结果，含使用的搜索算法及搜索路径等； 5. 实验结果分析； 6. 结论； 7. 提供全部源程序及软件的可执行程序。 附：实验报告格式 一、实验问题 二、实验目的 三、实验原理 四、程序框图 五、实验结果及分析 六、结论
用A算法解决八数码 问题
用A*算法解决八数码问题 一、 题目：八数码问题也称为九宫问题。在3×3的棋盘，有八个棋子，每个 棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要解决的问题是：任意给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。 二、 问题的搜索形式描述 状态：状态描述了8个棋子和空位在棋盘的9个方格上的分布。 初始状态：任何状态都可以被指定为初始状态。 操作符：用来产生4个行动（上下左右移动）。 目标测试：用来检测状态是否能匹配上图的目标布局。 路径费用函数：每一步的费用为1，因此整个路径的费用是路径中的步数。 现在任意给定一个初始状态，要求找到一种搜索策略，用尽可能少的步数得到上图的目标状态算法介绍 三、 解决方案介绍 1.A*算法的一般介绍 A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。对 于几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价 值，即 ()()()()()()**f g n sqrt dx nx dx nx dy ny dy ny =+--+--； 这样估价函数f 在g 值一定的情况下，会或多或少的受估价值h 的制 约，节点距目标点近，h 值小，f 值相对就小，能保证最短路的搜索向终点的方向进行。明显优于盲目搜索策略。
A star算法在静态路网中的应用 2.算法伪代码 创建两个表，OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。算起点的估价值，将起点放入OPEN表。 while(OPEN!=NULL) { 从OPEN表中取估价值f最小的节点n; if(n节点==目标节点) {break;} for(当前节点n 的每个子节点X) { 算X的估价值; if(X in OPEN) { if( X的估价值小于OPEN表的估价值 ) {把n设置为X的父亲; 更新OPEN表中的估价值; //取最小路径的估价值} } if(X inCLOSE) { if( X的估价值小于CLOSE表的估价值 )
1．启发式搜索算法A 启发式搜索算法A，一般简称为A算法，是一种典型的启发式搜索算法。其基本思想是：定义一个评价函数f，对当前的搜索状态进行评估，找出一个最有希望的节点来扩展。 评价函数的形式如下： f（n）＝g（n）＋h（n） 其中n是被评价的节点。 f（n）、g（n）和h（n）各自表述什么含义呢？我们先来定义下面几个函数的含义，它们与f（n）、g（n）和h（n）的差别是都带有一个"*"号。 g*(n)：表示从初始节点s到节点n的最短路径的耗散值； h*(n)：表示从节点n到目标节点g的最短路径的耗散值； f*(n)=g*(n)+h*(n)：表示从初始节点s经过节点n到目标节点g 的最短路径的耗散值。 而f（n）、g（n）和h（n）则分别表示是对f*（n）、g*（n）和h*（n）三个函数值的的估计值。是一种预测。A算法就是利用这种预测，来达到有效搜索的目的的。它每次按照f(n)值的大小对OPEN表中的元素进行排序，f值小的节点放在前面，而f 值大的节点则被放在OPEN表的后面，这样每次扩展节点时，都是选择当前f值最小的节点来优先扩展。
利用评价函数f（n）＝g（n）＋h（n）来排列OPEN表节点顺序的图搜索算法称为算法A。 过程A ①OPEN:＝（s），f（s）:＝g（s）+h（s）; ②LOOP：IF OPEN＝（）THEN EXIT（FAIL）； ③n:＝FIRST（OPEN）； ④IF GOAL（n）THEN EXIT（SUCCESS）； ⑤REMOVE（n，OPEN），ADD（n，CLOSED）； ⑥EXPAND（n）→{mi}，计算f（n，mi）＝g（n，mi）+h（mi）；g（n，mi）是从s通过n到mi的耗散值，f（n，mi）是从s通过n、mi到目标节点耗散值的估计。 ·ADD（mj，OPEN），标记mi到n的指针。 ·IF f（n，mk） 学生实验报告 实验课名称：人工智能 实验名称: 八数码 专业名称：计算机科学与技术 班级： 学号： 学生姓名： 教师姓名： 2010 年10 月20日 一．实验内容 用OPEN表和CLOSED表解决搜索问题。 二．实验题目 采用启发式算法（如A*算法）求解八数码问题。 三．实验要求 1.必须使用OPEN表和CLOSED表。 2.明确给出问题描述。系统初始状态。目标状态和启发式函数。 3.除了初始状态以外，至少搜索四层。 4.给出解路径（解图）。 四．实验过程 ①问题：初始状态到目标状态是否可解如何判断？ 答：实验过程自己给出的初始状态使用A*算法求解，并不是所有的初始状态都可解到达目标状态。因为八数码问题其实是0~9的一个排列，而排列有奇排列和偶排列，从奇排列不能转化为偶排列或者相反。例如：函数f(s)表示s前比s 小的数字的数目（s 则当f(a8)+f(a7)+……+f(a1)为偶数时才能重排成，所以嘛,上面那个有解的. ②问题描述： 在3X3的九宫格棋盘上，摆有8个将牌，每一个将牌都刻有1~8数码中的某一个数码。棋盘中留有一个空格，允许周围的某一个将牌向空格移动，这样通过移动将牌就可以不断地改变将牌的布局。这种游戏的求解的问题是：给定一种处 世的将牌布局或结构和一个目标的布局，问如何移动将牌，实现从从初始状态到目标状态的转变。 下面给出初始状态和目标状态： 初始状态：Array 目标状态： 评价函数f(n)形式为：f(n)=g(n)+h(n),其中g(n)是节点所处的深度， h(n)是启发式函数，这里启发式函数h(n)表示“不在位”的将牌个数，这时f(n) 注意：移动规则为左-→上→右→下。 ③搜索过程： 因此可得解路径：S(4)→B(4)→D(5)→E(5)→I(5)→K(5)→L(5). ④得到OPEN表和CLOSED表 OPEN表 人工智能作业八数码问题 一、题目 八数码问题： 初始状态图：目标状态图： 二、算符与状态空间 算符：左、上、右、下 状态空间： 状态：A=(X0,X1,X2,X3,X4,X5,X6,X7,X8) 初始状态：S0=(0,4,1,5,2,8,3,6,7); 目标状态：Sg=(0,1,7,5,2,8,3,6,4)。 三、搜索树 22 求解: 四、Open 表，Closed 表 Open 表： Closed 表： 五、程序代码 /* 3_13.pro eight puzzle */ trace DOMAINS state=st(in,in,in,in,in,in,in,in,in) in=integer DATABASE-mydatabase open(state,integer) closed(integer,state,integer) res(state) mark(state) fail_ PREDICATES solve search(state,state) result searching step4(integer,state) step56(integer,state) equal(state,state) repeat resulting(integer) rule(state,state) GOAL solve. CLAUSES solve:-search(st(0,4,1,5,2,8,3,6,7),st(0,1,7,5,2,8,3,6,4)),result. search(Begin,End):-retractall(_,mydatabase), assert(closed(0,Begin,0)),assert(open(Begin,0)), 1、程序源代码 #include 人工智能（A*算法） 一、 A*算法概述 A*算法是到目前为止最快的一种计算最短路径的算法，但它一种‘较优’算法，即它一般只能找到较优解，而非最优解，但由于其高效性，使其在实时系统、人工智能等方面应用极其广泛。 A*算法结合了启发式方法（这种方法通过充分利用图给出的信息来动态地作出决定而使搜索次数大大降低）和形式化方法（这种方法不利用图给出的信息，而仅通过数学的形式分析，如Dijkstra算法）。它通过一个估价函数（Heuristic Function）f(h)来估计图中的当前点p到终点的距离(带权值)，并由此决定它的搜索方向，当这条路径失败时，它会尝试其它路径。 因而我们可以发现，A*算法成功与否的关键在于估价函数的正确选择，从理论上说，一个完全正确的估价函数是可以非常迅速地得到问题的正确解答，但一般完全正确的估价函数是得不到的，因而A*算法不能保证它每次都得到正确解答。一个不理想的估价函数可能会使它工作得很慢，甚至会给出错误的解答。 为了提高解答的正确性，我们可以适当地降低估价函数的值，从而使之进行更多的搜索，但这是以降低它的速度为代价的，因而我们可以根据实际对解答的速度和正确性的要求而设计出不同的方案，使之更具弹性。 二、 A*算法分析 众所周知，对图的表示可以采用数组或链表，而且这些表示法也各也优缺点，数组可以方便地实现对其中某个元素的存取，但插入和删除操作却很困难，而链表则利于插入和删除，但对某个特定元素的定位却需借助于搜索。而A*算法则需要快速插入和删除所求得的最优值以及可以对当前结点以下结点的操作，因而数组或链表都显得太通用了，用来实现A*算法会使速度有所降低。要实现这些，可以通过二分树、跳转表等数据结构来实现，我采用的是简单而高效的带优先权的堆栈，经实验表明，一个1000个结点的图，插入而且移动一个排序的链表平均需500次比较和2次移动；未排序的链表平均需1000次比较和2次移动；而堆仅需10次比较和10次移动。需要指出的是，当结点数n大于10，000时，堆将不再是正确的选择，但这足已满足我们一般的要求。 实验三：A*算法求解8数码问题实验 一、实验目的 熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解N数码难题，理解求解流程和搜索顺序。 二、实验内容 1、八数码问题描述 所谓八数码问题起源于一种游戏:在一个3×3的方阵中放入八个数码1、2、3、4、5、6、7、8，其中一个单元格是空的。将任意摆放的数码盘（城初始状态）逐步摆成某个指定的数码盘的排列（目标状态）， 如图1所示 图1 八数码问题的某个初始状态和目标状态 对于以上问题，我们可以把数码的移动等效城空格的移动。如图1的 初始排列，数码7右移等于空格左移。那么对于每一个排列，可能的一次数码移动最多只有4中，即空格左移、空格右移、空格上移、空格下移。最少有两种（当空格位于方阵的4个角时）。所以，问题1 就转换成如何从初始状态开始，使空格经过最小的移动次数最后排列成目标状态。 2、八数码问题的求解算法 2.1 盲目搜索 宽度优先搜索算法、深度优先搜索算法 2.2 启发式搜索 启发式搜索算法的基本思想是：定义一个评价函数f，对当前的搜索状态进行评估，找出一个最有希望的节点来扩展。 先定义下面几个函数的含义： f*(n)=g*(n)+h*(n) (1) 式中g*(n)表示从初始节点s到当前节点n的最短路径的耗散值；h*(n)表示从当前节点n到目标节点g的最短路径的耗散值，f*(n)表示从初始节点s经过n到目标节点g的最短路径的耗散值。 评价函数的形式可定义如(2)式所示： f(n)=g(n)+h(n) (2) 其中n是被评价的当前节点。f(n)、g(n)和h(n)分别表示是对f*(n)、g*(n)和h*(n)3个函数值的估计值。 一、粒子群算法 粒子群算法，也称粒子群优化算法（Particle Swarm Optimization），缩写为PSO，是近年来发展起来的一种新的进化算法(（Evolu2tionary Algorithm - EA）。PSO 算法属于进化算法的一种，和遗传算法相似，它也是从随机解出发，通过迭代寻找最优解，它也是通过适应度来评价解的品质，但它比遗传算法规则更为简单，它没有遗传算法的交叉(Crossover) 和变异(Mutation) 操作，它通过追随当前搜索到的最优值来寻找全局最优。这种算法以其实现容易、精度高、收敛快等优点引起了学术界的重视，并且在解决实际问题中展示了其优越性。 优化问题是工业设计中经常遇到的问题,许多问题最后都可以归结为优化问题.为了解决各种各样的优化问题,人们提出了许多优化算法,比较著名的有爬山法、遗传算法等.优化问题有两个主要问题:一是要求寻找全局最小点,二是要求有较高的收敛速度.爬山法精度较高,但是易于陷入局部极小.遗传算法属于进化算法(EvolutionaryAlgorithms)的一种,它通过模仿自然界的选择与遗传的机理来寻找最优解.遗传算法有三个基本算子:选择、交叉和变异.但是遗传算法的编程实现比较复杂,首先需要对问题进行编码,找到最优解之后还需要对问题进行解码,另外三个算子的实现也有许多参数,如交叉率和变异率,并且这些参数的选择严重影响解的品质,而目前这些参数的选择大部分是依靠经验.1995年Eberhart博士和kennedy博士提出了一种新的算法;粒子群优化(ParticalSwarmOptimization-PSO)算法.这种算法以其实现容易、精度高、收敛快等优点引起了学术界的重视,并且在解决实际问题中展示了其优越性. 粒子群优化(ParticalSwarmOptimization-PSO)算法是近年来发展起来的一种新的进化算法(Evolu2tionaryAlgorithm-EA).PSO算法属于进化算法的一种,和遗传算法相似,它也是从随机解出发,通过迭代寻找最优解,它也是通过适应度来评价解的品质.但是它比遗传算法规则更为简单,它没有遗传算法的交叉(Crossover)和变异(Mutation)操作.它通过追随当前搜索到的最优值来寻找全局最优 二、遗传算法 遗传算法是计算数学中用于解决最佳化的，是进化算法的一种。进化算法最初是借鉴了进化生物学中的一些现象而发展起来的，这些现象包括遗传、突变、自然选择以及杂交等。遗传算法通常实现方式为一种模拟。对于一个最优化问题，一定数量的候选解（称为个体）的抽象表示（称为染色体）的种群向更好的解进化。传统上，解用表示（即0和1的串），但也可以用其他表示方法。进化从完全随机个体的种群开始，之后一代一代发生。在每一代中，整个种群的适应度被评价，从当前种群中随机地选择多个个体（基于它们的适应度），通过自然选择和突变产生新的生命种群，该种群在算法的下一次迭代中成为当前种群。 A*算法求解八数码问题 1、八数码问题描述 所谓八数码问题起源于一种游戏:在一个3×3的方阵中放入八个数码1、2、3、4、5、 6、7、8，其中一个单元格是空的。将任意摆放的数码盘（城初始状态）逐步摆成某个 指定的数码盘的排列（目标状态），如图1所示 图1 八数码问题的某个初始状态和目标状态 对于以上问题，我们可以把数码的移动等效城空格的移动。如图1的初始排列，数码7右移等于空格左移。那么对于每一个排列，可能的一次数码移动最多只有4中，即空格左移、空格右移、空格上移、空格下移。最少有两种（当空格位于方阵的4个角时）。所以，问题就转换成如何从初始状态开始，使空格经过最小的移动次数最后排列成目标状态。 2、八数码问题的求解算法 2.1 盲目搜索 宽度优先搜索算法、深度优先搜索算法 2.2 启发式搜索 启发式搜索算法的基本思想是：定义一个评价函数f，对当前的搜索状态进行评估，找出一个最有希望的节点来扩展。 先定义下面几个函数的含义： f*(n)=g*(n)+h*(n) (1) 式中g*(n)表示从初始节点s到当前节点n的最短路径的耗散值；h*(n)表示从当前节点n到目标节点g的最短路径的耗散值，f*(n)表示从初始节点s经过n到目标节点g 的最短路径的耗散值。 评价函数的形式可定义如(2)式所示： f(n)=g(n)+h(n) (2) 其中n是被评价的当前节点。f(n)、g(n)和h(n)分别表示是对f*(n)、g*(n)和h*(n)3个函数值的估计值。 利用评价函数f(n)=g(n)+h(n)来排列OPEN表节点顺序的图搜索算法称为算法A。在A算法中，如果对所有的x， h(x)<=h*(x) (3) 成立，则称好h(x)为h*(x)的下界，它表示某种偏于保守的估计。采用h*(x)的下界h(x)为启发函数的A算法，称为A*算法。 针对八数码问题启发函数设计如下： f(n)=d(n)+p(n) (4) 其中A*算法中的g(n)根据具体情况设计为d(n)，意为n节点的深度，而h(n)设计为 昆明理工大学信息工程与自动化学院学生实验报告 （2012 —2013 学年第 1 学期） 课程名称：人工智能开课实验室：信自楼442 2012 年10月 24日 一、上机目的及内容 1.上机内容 用确定性推理算法求解教材65-66页介绍的八数码难题。 2.上机目的 （1）复习程序设计和数据结构课程的相关知识，实现课程间的平滑过渡； （2）掌握并实现在小规模状态空间中进行图搜索的方法； （3）理解并掌握图搜索的技术要点。 二、实验原理及基本技术路线图（方框原理图或程序流程图） （1）设计并实现程序，求解出正确的解答路径； （2）对所设计的算法采用大O符号进行时间复杂性和空间复杂性分析； （3）对一般图搜索的技术要点和技术难点进行评述性分析。 问题描述： 在3×3组成的九宫格棋盘上，摆有八个将牌，每一个将牌都刻有1-8八个数码中的某一个数码。棋盘中留有一个空格，允许其周围的某一个将牌向空格移动，这样通过移动将牌就可以 不断改变将牌的布局。这种游戏求解的问题是：给定一种初始的将牌布局或结构（称初始状 态）和一个目标的布局（称目标状态），问如何移动将牌，实现从初始状态到目标状态的转变。 初始状态：8个数字将牌和空格在九宫格棋盘上的所有格局组成了问题的状态空间。其中，状态空间中的任一种状态都可以作为初始状态。 后继函数： 通过移动空格（上、下、左、右）和周围的任一棋子一次，到达新的合法状态。 目标测试： 比较当前状态和目标状态的格局是否一致。 路径消耗： 每一步的耗散值为1，因此整个路径的耗散值是从起始状态到目标状态的棋子移动的总步数。 三、所用仪器、材料（设备名称、型号、规格等或使用软件） 1台PC及VISUAL C++6.0软件 四、实验方法、步骤（或：程序代码或操作过程） 数据结构 static int target[9]={1,2,3,8,0,4,7,6,5}; 全局静态变量，表示目标状态class eight_num { private: int num[9]; 定义八数码的初始状态 int not_in_position_num; 定义不在正确位置八数码的个数 int deapth; 定义了搜索的深度 int eva_function; 评价函数的值，每次选取最小的进行扩展public: 人工智能实验一报告题目：采用A*算法解决八数码问题 姓名： XXX 学号： 10S003028 专业：计算机科学与技术 提交日期： 2011-05-04 目录 1问题描述........................................................................................................................... - 2 - 1.1待解决问题的解释............................................................................................... - 2 - 1.2问题的搜索形式描述............................................................................................ - 2 - 1.3解决方案介绍（原理）........................................................................................ - 3 - 2算法介绍........................................................................................................................... - 4 - 2.1A*搜索算法一般介绍............................................................................................ - 4 - 2.2 算法伪代码........................................................................................................... - 4 - 3算法实现........................................................................................................................... - 5 - 3.1 实验环境与问题规模........................................................................................... - 5 - 3.2 数据结构............................................................................................................... - 5 - 3.3 实验结果............................................................................................................... - 6 - 3.4系统中间及最终输出结果.................................................................................... - 6 - 4参考文献........................................................................................................................... - 7 - 5附录—源代码及其注释................................................................................................... - 7 - 1.在高血压诊断标准的变迁史上，（）将高血压的诊断标准定为120/80mmHg以下更受益。（ 2.0分） A.1949年 B.1984年 C.1993年 D.2016年 2.我国在语音语义识别领域的领军企业是（）。（2.0分） A.科大讯 飞 B.图谱科 技 C.阿里巴 巴 D.华为 3.中国人工智能产业初步呈现集聚态势,人工智能企业主要集聚在经济发达的一二线城市及沿海地区，排名第一的城市是（）。（2.0分） A. B.北京 C. D. 4.MIT教授Tomaso Poggio明确指出，过去15年人工智能取得的成功，主要是因为（）。（2.0分） A.计算机视 觉 B.语音识别 C.博弈论 D.机器学习 5.1997年，Hochreiter&Schmidhuber提出（）。（2.0分） A.反向传播算法 B.深度学习 C.博弈论 D.长短期记忆模型 6.（），中共中央政治局就人工智能发展现状和趋势举行第九次集体学习。（2.0分） A.2018年3月15日 B.2018年10月31日 C.2018年12月31日 D.2019年1月31日 7.（）是指能够自己找出问题、思考问题、解决问题的人工智能。（2.0分） A.超人工智 能 B.强人工智 能 C.弱人工智 能 D.人工智能 8.据清华原副校长施一公教授研究，中国每年有265万人死于（），占死亡人数的28%。（2.0分） A.癌症 B.心脑血管疾病 C.神经退行性疾 病 D.交通事故 9.2005年，美国一份癌症统计报告表明：在所有死亡原因中，癌症占（）。（2.0分） A.1/4 B.1/3 C.2/3 D.3/4 10.（）是自然语言处理的重要应用，也可以说是最基础的应用。（2.0分） A.文本识别 B.机器翻译 C.文本分类 D.问答系统 11.（）是人以自然语言同计算机进行交互的综合性技术，结合了语言学、心理学、工程、计算机技术等领域的知识。（2.0分） A.语音交互 B.情感交互 C.体感交互 D.脑机交互 12.下列对人工智能芯片的表述，不正确的是（）。（2.0分） A.一种专门用于处理人工智能应用中大量计算任务的芯片 B.能够更好地适应人工智能中大量矩阵运算 C.目前处于成熟高速发展阶段 D.相对于传统的CPU处理器，智能芯片具有很好的并行计算性能 13.（）是指能够按照人的要求，在某一个领域完成一项工作或者一类工作的人工智能。（2.0分） A.超人工智 能 B.强人工智 能 C.弱人工智 能 D.人工智能 人工智能上机实验二八数码问题的求解策略1、广度优先算法程序截图： 2、最佳优先算法程序截图： （接上图） 3、程序代码： ①广度优先算法： (defun init-search (start goal) (declare (special *open*)) (declare (special *closed*)) (declare (special *moves*)) (declare (special *start*)) (declare (special *goal*)) (let (tuple) (setq tuple (cons start '(nil)) ) (setq *open* (list tuple) ) (setq *closed* nil ) (setq *start* start) (setq *goal* goal) (setq *moves* '(blank-left blank-up blank-right blank-down)) (breadth-first-search))) (defun breadth-first-search () (declare (special *open*)) (declare (special *closed*)) (declare (special *goal*)) (declare (special *moves*)) (let (state tuple children path) (cond ((null *open*) 'FAIL!) (t (setq tuple (car *open*) ) (setq state (car tuple) ) (setq *open* (cdr *open*) ) (setq *closed* (cons tuple *closed*)) (cond ((equal state *goal*) (setq path (get-path-from *goal*)) (setq path (reverse path)) (print-path path) #include 人工智能算法实现：[1]A*算法c语言 ? 分步阅读 A*算法，A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。估价值与实际值越接近，估价函数取得就越好。 A*[1]（A-Star)算法是一种静态路网中求解最短路最有效的方法。 公式表示为：f(n)=g(n)+h(n), 其中f(n) 是从初始点经由节点n到目标点的估价函数， g(n) 是在状态空间中从初始节点到n节点的实际代价， h(n) 是从n到目标节点最佳路径的估计代价。 保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取： 估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。 如果估价值>实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。 工具/原料 ?DEVC++或VC 6.0 方法/步骤 1.估价值与实际值越接近，估价函数取得就越好 例如对于几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价值，即f=g(n)+sqrt((dx-nx)*(dx-nx)+(dy-ny)*(dy-ny))；这样估价函数f在g值一定的情况下，会或多或少的受估价值h的制约，节点距目标点近，h值小，f 值相对就小，能保证最短路的搜索向终点的方向进行。明显优于Dijkstra算法的毫无方向的向四周搜索。 conditions of heuristic Optimistic (must be less than or equal to the real cost) As close to the real cost as possible 详细内容： 创建两个表，OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。 算起点的估价值; 将起点放入OPEN表; 2. A star算法在静态路网中的应用，以在地图中找从开始点s 到e点的最短 行走路径为例： 首先定义数据结构 #define MAPMAXSIZE 100 //地图面积最大为100x100 #define MAXINT 8192 //定义一个最大整数, 地图上任意两点距离不会超过它#define STACKSIZE 65536 //保存搜索节点的堆栈大小 #define tile_num(x,y) ((y)*map_w+(x)) //将x,y 坐标转换为地图上块的编号#define tile_x(n) ((n)%map_w) //由块编号得出x,y 坐标 #define tile_y(n) ((n)/map_w) // 树结构, 比较特殊, 是从叶节点向根节点反向链接八数码实验报告人工智能课设报告
人工智能 八数码实验
启发式搜索算法解决八数码问题(C语言)
A-算法人工智能课程设计
实验三A星算法求解8数码问题实验讲解
人工智能基础算法
A星算法求解八数码问题
人工智能试验-八数码难题
采用A算法解决八数码问题
2019年人工智能考试题答案
人工智能实验八数码问题的求解策略
八数码C语言A算法详细代码
人工智能算法实现
相关主题
文本预览