人工智能实验报告总.docx
《人工智能实验报告总.docx》由会员分享，可在线阅读，更多相关《人工智能实验报告总.docx（88页珍藏版）》请在冰豆网上搜索。
人工智能实验报告总
人工智能课内实验报告
（8次）
学院：
自动化学院
班级：
智能
姓名：
学号：
06
人工智能课内实验报告
实验1：
猴子摘香蕉问题的VC编程实现
学院：
自动化学院
班级：
姓名：
学号：
日期
实验1：
猴子摘香蕉问题的VC编程实现
一、实验目的
（1）熟悉谓词逻辑表示法；
（2）掌握人工智能谓词逻辑中的经典例子——猴子摘香蕉问题的编程实现。
二、编程环境
VC语言
三、问题描述
房子里有一只猴子（即机器人），位于a处。
在c处上方的天花板上有一串香蕉，猴子想吃，但摘不到。
房间的b处还有一个箱子，如果猴子站到箱子上，就可以摸着天花板。
如图1所示，对于上述问题，可以通过谓词逻辑表示法来描述知识。
要求通过VC语言编程实现猴子摘香蕉问题的求解过程。
图1猴子摘香蕉问题
四、源代码
#include
inti;
voidgo（charx,chary）
{
printf（"step%d:
monkey从%c走到%c\n",++i,x,y）;
}
voidmovebox（charx,chary）
{
printf（"step%d:
monkey把箱子从%c运到%c\n",++i,x,y）;
}
voidonbox（）
{
printf（"step%d:
monkey爬上箱子\n",++i）;
}
voidcatchbanana（）
{
printf（"step%d:
monkey摘到香蕉\n",++i）;
}
intmain（）
{
charmonkey,box,banana;
printf（"请用abc来表示猴子箱子香蕉的位置\n"）;
printf（"monkey\tbox\tbananna\n"）;
scanf（"%c",&monkey）;
getchar（）;
printf（"\t"）;
scanf（"%c",&box）;
getchar（）;
printf（"\t\t"）;
scanf（"%c",&banana）;
getchar（）;
printf（"操作步骤如下\n"）;
if（monkey!
=box）
{
go（monkey,box）;
}
if（box!
=banana）
{
movebox（box,banana）;
}
onbox（）;
catchbanana（）;
printf（"\n"）;
getchar（）;
}
五、实验结果相关截图
六、心得体会
本次实验通过VC++编程实现了经典问题“猴子摘香蕉”。
首先我定义了谓词，其次找个体的变量范围，最后确定了问题初始状态与目标状态。
然后在程序中设置函数，确定变量，最后显示出猴子摘到香蕉的每个步骤。
通过本次实验对用人工智能的知识解决问题有了初步的了解，但由于自身的C语言编程能力较差，实验过程不是很顺利，后来通过向编程能力强的同学请教顺利的完成了本次试验。
人工智能课内实验报告
实验2：
编程实现简单动物识别系统的知识表示
学院:
自动化学院
班级：
姓名：
学号：
日期：
实验2：
编程实现简单动物识别系统的知识表示
一、实验目的
1.理解和掌握产生式知识表示方法；
2.能够通过VC编程语言实现产生式系统的规则库。
二、实验内容
1.以动物识别系统的产生式规则为例；
2.用选定的编程语言建造规则库和综合数据库，并能对它们进行增加、删除和修改操作。
三、实验步骤
1.确定需要识别的动物及其属性
本次实验的简单动物识别系统总共能识别7种动物，即：
老虎、金钱豹、斑马、长颈鹿、企鹅、鸵鸟和信天翁。
2.建立识别七种动物识别系统的规则
3.选定编程语言并确定综合数据库和规则库结构
（1）选用C语言作为编程语言
（2）综合数据库的建立
（3）规则库的建立
四、程序源代码
#include
voidbirds（）//鸟类动物识别
{
inta;
printf（"**************************************\n"）;
printf（"1.长腿，长脖子，黑色，不会飞。
\n"）;
printf（"2.不会飞，会游泳，黑色.\n"）;
printf（"3.善飞\n"）;
printf（"4.无上述特征\n"）;
printf（"**************************************\n\n"）;
printf（"请选择该动物特点：
\n"）;
scanf（"%d",&a）;
switch（a）
{
case1:
printf（"该动物为\"鸵鸟\"\n\n"）;
break;
case2:
printf（"该动物为\"企鹅\"\n\n"）;
break;
case3:
printf（"该动物为\"信天翁\"\n\n"）;
break;
case4:
printf（"\"我们将会尽快升级系统，谢谢使用。
\"\n\n"）;
break;
default:
printf（"错误选择!
\n"）;
break;
}}
voidcarnivore（）//食肉动物识别
{
intd;
printf（"**************************************\n"）;
printf（"1.黄褐色有暗斑\n2.黄褐色有褐色条纹\n3.无上述特点\n"）;
printf（"**************************************\n\n"）;
printf（"请选择该动物特点：
\n"）;
scanf（"%d",&d）;
switch（d）
{
case1:
printf（"该动物为\"猎豹\"\n\n"）;
break;
case2:
printf（"该动物为\"老虎\"\n\n"）;
break;
case3:
printf（"\"我们将会尽快升级系统，谢谢使用。
\"\n\n"）;
break;
default:
printf（"错误选择!
\n"）;
break;
}}
voidungulate（）//哺乳动物识别
{
inte;
printf（"**************************************\n"）;
printf（"1.黑白条纹\n2.有暗斑点，且长腿，长脖子\n3.无上述特点\n"）;
printf（"**************************************\n"）;
printf（"请选择该动物特点：
\n\n"）;
scanf（"%d",&e）;
switch（e）
{
case1:
printf（"该动物为\"斑马\"\n\n"）;
break;
case2:
printf（"该动物为\"长颈鹿\"\n\n"）;
break;
case3:
printf（"\"我们将会尽快升级系统，谢谢使用。
\"\n\n"）;
break;
default:
printf（"错误选择!
\n"）;
break;
}}
intmain（）
{
while
（1）
{
intc;
printf（"动物专家识别系统\n\n"）;
printf（"**************************************\n"）;
printf（"1.有羽毛或会飞或会下蛋\n2.该动物有蹄或会反刍\n3.吃肉或有犬齿\n"）;
printf（"**************************************\n\n"）;
printf（"请选择该动物特点：
\n"）;
scanf（"%d",&c）;
switch（c）
{
case1:
printf（"该动物属于\"鸟类\"\n"）;
birds（）;
break;
case2:
printf（"该动物属于\"哺乳类动物\"\n"）;
ungulate（）;
break;
case3:
printf（"该动物属于\"食肉动物\"\n"）;
carnivore（）;
break;
case4:
printf（"\"我们将会尽快升级系统，谢谢使用。
\"\n"）;
break;
default:
printf（"错误选择!
\n"）;
break;
}}}
五、实验结果相关截图
六、心得体会
本次试验的重点是综合数据库的建立和规则库的建立，本次实验的问题求解过程是一个不断地从规则库中选取可用规则与综合数据库中的已知事实进行匹配的过程，规则的每一次匹配都会使综合数据库增加新的内容，并朝着问题的解决前进了一步。
这就是一个推理过程。
通过本次实验我用VC编程实现了人工智能中的经典问题动物识别专家系统，我对用人工智能的知识解决问题有了进一步的了解，但由于我的编程能力较差，不能完整的写出程序，后来通过搜索网上的例题，参考例题，最终完整的完成了本次试验。
人工智能课内实验报告
实验3：
盲目搜索求解8数码问题
学院:
自动化学院
班级：
姓名：
学号：
日期：
实验3：
盲目搜索求解8数码问题
一、实验目的
（1）熟悉人工智能系统中的问题求解过程；
（2）熟悉状态空间中的盲目搜索策略；
（3）掌握盲目搜索算法，重点是宽度优先搜索和深度优先搜索算法。
二、实验要求
用VC语言编程，采用宽度优先搜索和深度优先搜索方法，求解8数码问题
三、实验内容
（1）采用宽度优先算法，运行程序，要求输入初始状态
假设给定如下初始状态S0
283
164
705
和目标状态Sg
216
408
753
验证程序的输出结果，写出心得体会。
（2）对代码进行修改（选作），实现深度优先搜索求解该问题
提示：
每次选扩展节点时，从数组的最后一个生成的节点开始找，找一个没有被扩展的节点。
这样也需要对节点添加一个是否被扩展过的标志。
四、源代码
#include
#include
#include
#defineMAX_NODESIZE362880//9的阶乘9!
=362880
typedefstructnode{//八数码结构体
inta[3][3];//节点状态
//空格下标
inti_0;
intj_0;
//启发信息
intd;//搜索深度
intw;//各棋子不在正确位置的数目
intf;//总代价
structnode*father;//指向父节点指针
}
node,*p_node;
typedefstructlist//顺序表结构体
{
p_nodea[MAX_NODESIZE];
longlength;
}
list,*p_list;
//staticints0[3][3]={2,8,3,1,6,4,7,0,5};//初始结点
staticints0[3][3]={2,8,3,1,6,4,7,0,5};//初始结点
/*
283
164
705
*/
staticintsg[3][3]={2,1,6,4,0,8,7,5,3};//目标结点
/*
216
408
753
*/
p_nodes_0=（p_node）malloc（sizeof（node））;//初始节点
p_nodes_g=（p_node）malloc（sizeof（node））;//目标节点
p_listOPEN=（p_list）malloc（sizeof（list））;//OPEN表
p_listCLOSED=（p_list）malloc（sizeof（list））;//CLOSE表
intw（p_nodes）;//计算各将牌不在正确位置的数目
intf（p_nodes）;//估价函数
voidinit_node（）;//初始化
voidout_node（p_nodes）;//输出八数码
voidlist_reverse（p_node&p）;//将链表逆序
voidout_list（p_list&l）;//输出OPEN表
boolsearch_list（p_list&l,p_nodes）;//对表进行查找，成功返回true
voidsort_list（p_list&l）;//对OPEN表进行排序（按f从小到大）
voidadd_list（p_list&l,p_nodes）;//加入结点到OPEN表中或CLOSE表中
voidcopy_node（p_nodes1,p_node&s2）;//生成新的结点（将s2赋值给s1）
voiddelete_list（p_list&l）;//从OPEN表或CLOSE中删除结点
boolis_equal（p_nodes1,p_nodes2）;//判断两节点是否相等
boolup_mov（p_node&s）;//空格上移
booldown_mov（p_node&s）;//空格下移
boolleft_mov（p_node&s）;//空格左移
boolright_mov（p_node&s）;//空格右移
voidmove（p_nodes）;//移动父节点并加入未探索表中（扩展结点）
intmain（）
{
init_node（）;
printf（"\n程序求解过程如下：
\n"）;
printf（"=========================================================\n\n"）;
while（OPEN->length!
=0&&CLOSED->length<=1000）//最多循环次数1000
{
p_noden=OPEN->a[0];//---------------把Open表的第一个节点取出放入Closed表，并记该节点为n
delete_list（OPEN）;
if（is_equal（n,s_g））//考察节点n是否为目标节点。
若是，则找到了问题的解，成功退出；亦可换成if（w（n）==0）{...}
{
list_reverse（n）;
list_reverse（n）;
list_reverse（n）;
while（n）
{
printf（"第%d步：
\n",n->d+1）;
out_node（n）;
n=n->father;
}
break;
}
add_list（CLOSED,n）;
move（n）;//扩展结点n
sort_list（OPEN）;
//out_list（OPEN）;
}
if（OPEN->length==0||CLOSED->length>1000）
{
printf（"\n从初始结点无法到达目标结点！
\n\n"）;
}
return0;
}
intf（p_nodes）//估价函数
{
return（s->d+s->w）;
}
voidout_node（p_nodes）//输出八数码
{
printf（"-------------------"）;
printf（"x=%d,y=%d\n",s->i_0,s->j_0）;
for（inti=0;i<3;i++）
{
for（intj=0;j<3;j++）
{
printf（"%5d",s->a[i][j]）;
}
printf（"\n"）;
}
printf（"-------------------"）;
printf（"d=%d,w=%d;f=%d\n\n\n",s->d,s->w,s->f）;
}
voidout_list（p_list&l）//输出OPEN表
{
printf（"****************************************************************\n"）;
for（inti=0;ilength;i++）
{
out_node（l->a[i]）;
}
printf（"****************************************************************\n"）;
}
intw（p_nodes）//计算各棋子不在正确位置的数目
{
intw=0;
for（inti=0;i<3;i++）
{
for（intj=0;j<3;j++）
{
if（s->a[i][j]!
=sg[i][j]）
{
w++;
}}}
if（s->a[1][1]==sg[1][1]）
{
w+=1;
}
returnw-1;
}
boolleft_mov（p_node&s）//空格左移
{
intx=s->i_0,y=s->j_0;
if（y==0）
{
returnfalse;
}
intt;
t=s->a[x][y];
s->a[x][y]=s->a[x][y-1];
s->a[x][y-1]=t;
--s->j_0;
returntrue;
}
boolright_mov（p_node&s）//空格右移
{
intx=s->i_0,y=s->j_0;
if（y==2）
{
returnfalse;
}
intt;
t=s->a[x][y];
s->a[x][y]=s->a[x][y+1];
s->a[x][y+1]=t;
++s->j_0;
returntrue;
}
boolup_mov（p_node&s）//空格上移
{
intx=s->i_0,y=s->j_0;
if（x==0）
{
returnfalse;
}
intt;
t=s->a[x][y];
s->a[x][y]=s->a[x-1][y];
s->a[x-1][y]=t;
--s->i_0;
returntrue;
}
booldown_mov（p_node&s）//空格下移
{
intx=s->i_0,y=s->j_0;
if（x==2）
{
returnfalse;
}
intt;
t=s->a[x][y];
s->a[x][y]=s->a[x+1][y];
s->a[x+1][y]=t;
++s->i_0;
returntrue;
}
boolis_equal（p_nodes1,p_nodes2）//判断两节点是否相等
{
for（inti=0;i<3;i++）
{
for（intj=0;j<3;j++）
{
if（s1->a[i][j]!
=s2->a[i][j]）
{
returnfalse;
}}}
returntrue;
}
voidcopy_node（p_nodes1,p_node&s2）//生成新的结点（将s2赋值给s1）
{
for（inti=0;i<3;i++）
{
for（intj=0;j<3;j++）
{
s1->a[i][j]=s2->a[i][j];
}}
s1->i_0=s2->i_0;
s1->j_0=s2->j_0;
s1->d=s2->d;
s1->w=s2->w;
s1->f=s2->f;
s1->father=s2->father;
}
voidadd_list（p_list&l,p_nodes）//加入结点到OPEN表中或CLOSE表中
{
l->a[l->length++]=s;
}
voiddelete_list（p_list&l）//从OPEN表或CLOSE中删除结点
{
for（inti=0;ilength;i++）
{
l->a[i]=l->a[i+1];
}
l->length--;
}
boolsearch_list（p_list&l,p_nodes）//对表进行查找，成功返回true
{
for（inti=0;ilength;i++）
{
if（is_equal（l->a[i],s））
returntrue;
}
returnfalse;
}
voidmove（p_nodes）//移动父节点并加入未探索表中（扩展结点）
{
p_nodep1=（p_node）malloc（sizeof（node））;
p_nodep2=（p_node）malloc（sizeof（node））;
p_nodep3=（p_node）malloc（sizeof（node））;
p_nodep4=（p_node）malloc（sizeof（node））;
copy_node（p1,s）;
copy_node（p2,s）;
copy_node（p3,s）;
copy_node（p4,s）;
p1->father=s;
p2->father=s;
p3->father=s;
p4->father=s;
//如果能够移动且在CLOSED表中不存在，则加入OPEN表中
if（left_mov（p1）&&!
is_equal（p1,p1->father）&&!
search_list（CLOSED,p1）&&!
search_list（OPEN,p1））
{
add_list（OPEN,p1）;
p1->d+=1;
p1->w=w（p1）;
p1->f=f（p1）;
}
else
{
free（p1）;
}
if（right_mov（p2）&&!
is_equal（p2,p2->father）&&!
search_list（CLOSED,p2）&&!
search_list（OPEN,p2））
{
add_l
升级会员 