人工智能大作业实验.docx

人工智能大作业实验.docx

《人工智能大作业实验.docx》由会员分享，可在线阅读，更多相关《人工智能大作业实验.docx（29页珍藏版）》请在冰豆网上搜索。

人工智能大作业实验

湖南中医药大学本科课程实验教学大纲

《人工智能》

计算机科学与技术专业

执笔人:

丁长松

审定人:

*＊＊

学院负责人：

＊＊＊

湖南中医药大学教务处

二○一四年三月

一、课程性质和教学目的

《人工智能》是计算机专业本科生的一门专业必修课，适应于计算机科学与技术专业、医药信息工程专业。

本课程是关于人工智能领域的引导性课程，通过本课程的学习，是使学生了解和掌握人工智能的基本概念、原理和方法，培养学生在计算机领域中应用人工智能技术提高分析和解决较复杂问题的能力，启发学生对人工智能的兴趣,培养知识创新和技术创新能力。

《人工智能》主要研究智能信息处理技术、开发具有智能特性的各类应用系统的核心技术。

本课程主要介绍人工智能的基本理论、方法和技术，主要包括常用的知识表示、逻辑推理和问题求解方法、人工智能发展学派以及主要理论。

先修课程：

高等数学、数据结构、数据库原理、算法设计与分析、数理逻辑

二、课程目标

人工智能实验应在一种为高效率开发专家系统而设计的高级程序系统或高级程序设计语言环境中进行。

在目前开来，专家系统开发工具和环境可分为5种主要类型：

程序设计语言、知识工程语言、辅助型工具、支持工具及开发环境.在这里主要是要求学生能用相关术语描述、表示一些问题；用程序设计语言如：

C、C++、JAVA编程来实现一些基本的算法、推理、搜索等过程。

三、实验内容与要求

实验一：

谓词表示

【实验内容】

设农夫、狼、山羊、白菜都在河的左岸，现在要把它们运送到河的右岸去，农夫有条船，过河时，除农夫外船上至多能载狼、山羊、白菜中的一种.狼要吃山羊，山羊要吃白菜，除非农夫在那里。

试设计出一个确保全部都能过河的方案。

【实验目的】

让学生加深对谓词逻辑和谓词知识表示的理解.  

【实验要求】

写出所用谓词的定义，并给出每个谓词的功能及变量的个体域，然后编程来实现。

【参考学时】

1.定义状态的谓词

2.定义变元的个体域

3.描述问题的初始和目标状态

4.定义动作

5.解释过程

解:

（1）先定义描述状态的谓词

AL（x）：

x在左岸

¬AL（x）表示x在右岸。

（2）定义个体域

x的个体域：

｛农夫，船，狼，羊,白菜｝。

（3）定义初始状态和目标状态

问题的初始状态：

AL（农夫），AL（船），AL（狼），AL（羊），AL（白菜），

问题的目标状态:

¬AL（农夫），¬AL（船），¬AL（狼）,¬AL（羊），¬AL（白菜）

（4）定义动作

4个动作：

农夫不带来回

农夫带来回

L-R：

农夫自己划船从左岸到右岸

L-R（x）：

农夫带着x划船从左岸到右岸

R-L：

农夫自己划船从右岸到左岸

R—L（x）：

农夫带着x划船从右岸到左岸

x的个体域是｛狼，羊,白菜｝。

L—R：

农夫划船从左岸到右岸

条件：

AL（船），AL（农夫），¬AL（狼）∨¬AL（羊），¬AL（羊）∨¬AL（白菜）

动作：

删除表：

AL（船）,AL（农夫）

添加表：

¬AL（船），¬AL（农夫）

L—R（狼）：

农夫带着狼划船从左岸到右岸

条件：

AL（船），AL（农夫），AL（狼）,¬AL（羊）

动作：

删除表：

AL（船）,AL（农夫），AL（狼）

添加表：

¬AL（船）,¬AL（农夫），¬AL（狼）

L-R（羊）:

农夫带着羊划船从左岸到右岸

条件：

AL（船），AL（农夫），AL（羊），AL（狼）,AL（白菜）

或：

AL（船），AL（农夫），AL（羊），¬AL（狼），¬AL（白菜）

动作:

删除表：

AL（船），AL（农夫），AL（羊）

添加表：

¬AL（船），¬AL（农夫）,¬AL（羊）

L-R（白菜）：

农夫带着白菜划船从左岸到右岸

条件：

AL（船）,AL（农夫），AL（白菜），¬AL（狼）

动作：

删除表：

AL（船），AL（农夫），AL（白菜）

添加表：

¬AL（船），¬AL（农夫），¬AL（白菜）

R—L：

农夫划船从右岸到左岸

条件:

¬AL（船），¬AL（农夫）,AL（狼）∨AL（羊）,AL（羊）∨AL（白菜）

或：

¬AL（船），¬AL（农夫），¬AL（狼），¬AL（白菜），AL（羊）

动作:

删除表：

¬AL（船），¬AL（农夫）

添加表：

AL（船），AL（农夫）

R-L（羊）：

农夫带着羊划船从右岸到左岸

条件：

¬AL（船），¬AL（农夫），¬AL（羊），¬AL（狼）,¬AL（羊），AL（白菜）

动作：

删除表：

¬AL（船），¬AL（农夫），¬AL（羊）

添加表：

AL（船），AL（农夫）,AL（羊）

（3）问题求解过程

代码如下

＃include〈stdio.h〉

＃include

h〉

typedefintdatatype；//datatype定义

structseqque//队列结构体

｛

intmaxnum;

intf,r;//存放头尾下标

datatype＊q；

};

typedefstructseqque*pseqque；

/*创建一个新的队列*/

pseqquecreatemptyqueue（intm）

｛

pseqquepaqu=（pseqque）malloc（sizeof（structseqque））；//申请结构体动态空间

if（paqu!

=NULL）

{

paqu—〉q=（datatype*）malloc（sizeof（datatype）＊m）;//申请datatype动态空间

if（paqu—〉q）

｛

paqu-〉maxnum=m;

paqu-〉f=0；//置头下标为0

paqu->r=0；//置尾下标为0

returnpaqu；

｝

elsefree（paqu）;

｝

printf（”超出存储空间!

"）;

returnNULL;

｝

/＊入队运算函数＊/

voidenque（pseqquepaqu,datatypex）

{

if（（paqu—〉r+1）%（paqu—>maxnum）==paqu-〉f）

printf（"队列已满！

”）;

else

{

paqu-〉q［paqu—〉r]=x;

paqu->r=（paqu-〉r+1）％（paqu->maxnum）;

｝

｝

/＊出队运算函数＊/

voiddeque（pseqquepaqu）

{

if（paqu-〉f==paqu->r）

printf（"空队列!

"）;

else

paqu—〉f=（paqu—>f+1）%（paqu—>maxnum）；

｝

/*取队列头元素*/

datatypefrontque（pseqquepaqu）

{

if（paqu—〉f==paqu—>r）

printf（”队列为空！

"）;

else

return（paqu—>q［paqu->f]）；

｝

/*判断是否为空队列函数*/

intisemptyque（pseqquepaqu）

｛

if（paqu->f==paqu-〉r）

return1;

else

return0;

｝

/＊判断农夫位置*/

intfarmer（intlocation）

｛

return（0！

=（location＆0x08））；

｝

/＊判断狼位置*/

intwolf（intlocation）

｛

return（0！

=（location＆0x04））;

}

/＊判断白菜位置*/

intcabbage（intlocation）

{

return（0！

=（location&0x02））;

｝

/＊判断羊位置＊/

intgoat（intlocation）

｛

return（0!

=（location＆0x01））；

}

/*安全状态的判断函数＊/

intsafe（intlocation）

｛

if（（goat（location）==cabbage（location））&&（goat（location）!

=farmer（location）））

return0;//羊吃白菜

if（（goat（location）==wolf（location））&＆（wolf（location）！

=farmer（location）））

return0；//狼吃羊

return1;

｝

/＊解决农夫问题函数*/

voidfarmerproblem（void）

{

inti，movers,location,newlocation;

introute［16]；//记录已走过的步骤

pseqquemoveto;//存放安全的步骤

moveto=createmptyqueue（16）；//创建新队列

enque（moveto,0x00）；//置状态初值

for（i=0;i〈16;i++）//置已走过步骤初值

route[i］=-1;

route[0]=0；

while（!

isemptyque（moveto）&＆（route［15]==—1））

｛

location=frontque（moveto）；//取头状态为当前状态

deque（moveto）；//删除队列头状态

for（movers=1;movers<=8;movers<<=1）//依次考虑羊、白菜、狼、农夫的移动

if（（0!

=（location＆0x08））==（0!

=（location&movers）））//判断是否和农夫同边

{

newlocation=location^（0x08|movers）;//移动后的状态

if（safe（newlocation）&＆（route［newlocation]==—1））//判断是否为安全状态

｛

route[newlocation]=location;//将新的安全状态赋给location

enque（moveto,newlocation）；//新的状态入队列

｝

｝

｝

if（route[15]!

=—1）//到达最终状态

{

printf（”过程是:

\n”）;//输出过程和位置

for（location=15；location>=0；location=route［location]）

｛

printf（”位置是：

%d\n”，location）；

if（location==0）

exit（0）;

}

｝

elseprintf（"此问题无解！

”）；

｝

/*主函数＊/

voidmain（）

{

farmerproblem（）;

｝

实验二：

一个用于动物识别的产生式系统    

【实验内容】      

设计该系统,让其实现可以识别老虎、金钱豹、斑马、长颈鹿、企鹅、信天翁这6种动物。

【实验目的】

让学生进一步加深对产生式系统的认识和理解。

【实验要求】

其规则库中应包含至少15条规则,假设推理开始时综合数据库中存放有以下事实：

动物有暗斑，有长脖子，有长腿，有奶，有蹄。

【参考学时】

6课时：

上机实验6课时。

设计如下：

（1）IDENTIFIER产生式规则

规则I1：

如果该动物有毛发

那么它是哺乳动物

规则I2：

如果该动物有奶

那么它是哺乳动物

规则I3：

如果该动物有羽毛

那么它是鸟类动物

规则I4：

如果该动物能生蛋

它能飞行

那么它是鸟类动物

给出的六种动物除了哺乳动物即是鸟类动物，故I1-I4这一组规则可用于区分这两类动物。

规则I5：

如果该动物是哺乳动物

它吃肉

那么它是肉食动物

规则I6:

如果该动物是哺乳动物

它长有爪子

它长有利齿

它眼睛前视

那么它是肉食动物

规则I7：

如果该动物是哺乳动物

它长有蹄

那么它是有蹄动物

规则I8：

如果该动物是哺乳动物

它反刍

那么它是有蹄动物，并且是偶蹄动物

I5-I8用于区分哺乳动物中的食肉动物和有蹄动物。

规则I9：

如果该动物是食肉动物

它有暗斑

那么它是金钱豹

规则I10:

如果该动物是食肉动物

它没有暗斑

它有黄色条纹

那么它是老虎

I9-I10用于区分肉食动物。

规则I11:

如果该动物是有蹄动物

它有长脖子

那么它是长颈鹿

规则I12：

如果该动物是有蹄动物

它没有长脖子

它有黑白条纹

那么它是斑马

I11-I12用于区分蹄型动物。

规则I13：

如果该动物是鸟类

它有能游水

那么他是会水鸟类

规则I14：

如果该动物是鸟类

它有长腿

它会飞

那么它是信天翁

规则I15：

如果该动物是会水鸟类

它不会飞

它是黑色和白色的

那么它是信企鹅

I13—I15用于区分鸟类动物.

代码如下:

＃include〈stdio。

h>

#include

intmain（）

｛

inta[5]=｛0，0,0,0,0};

printf（”请输入该动物的特征有的特征输入1无的特征输入0\n\n”）;

for（intk=0;k<5；k++）

{

if（k==0）

printf（”该动物是否有奶？

\n”）；

elseif（k==1）

printf（"该动物是否有蹄？

\n”）;

elseif（k==2）

printf（"该动物是否有长腿？

\n”）；

elseif（k==3）

printf（"该动物是否有暗斑？

\n”）；

elseif（k==4）

printf（”该动物是否有长脖子？

\n"）；

scanf（”％d”，＆a[k]）;

}

printf（”输入的序列为:

”）；

for（intj=0；j〈5；j++）

｛

printf（”％d",a［j]）;

}

printf（”\n"）；

intb=-1；

for（inti=0;i〈5；i++）

{

if（i==0）{

if（a[i]==1）｛

printf（"该动物是哺乳动物\n”）；

b=1;

}

if（a[i］==0）｛

printf（”该动物不是哺乳动物\n”）;

b=0;

}

｝

if（i==1）{

if（a[i]==1&&b==1）{

printf（"该动物是有蹄动物\n"）；

b=11；

｝

if（a[i]==0&＆b==1）{

printf（"该动物不是有蹄动物\n"）；

b=10；

}

｝

if（i==2）｛

if（a[i］==1&＆b==0）｛

printf（”该动物有长腿\n”）;

b=01;//信天翁

}

if（a［i]==0＆&b==0）｛

printf（”该动物没有长腿\n”）；

b=00;//企鹅

}

}

if（i==3）｛

if（a[i]==1＆&b==10）{

printf（”该动物有暗斑\n”）；

b=101;//猎豹

}

if（a［i]==0＆&b==10）{

printf（”该动物无暗斑\nn"）；

b=100；//老虎

}

｝

if（i==4）{

if（a［i]==1&＆b==11）｛

printf（"该动物有长脖子\n”）;

b=111；//长颈鹿

｝

if（a［i］==0&&b==11）{

printf（"该动物没有长脖子\n”）;

b=110；//斑马

}

｝

｝

if（b==01）

printf（”该动物是信天翁\n"）；

elseif（b==00）

printf（"该动物是企鹅\n”）；

elseif（b==101）

printf（”该动物是猎豹\n”）;

elseif（b==100）

printf（"该动物是老虎\n"）；

elseif（b==111）

printf（”该动物是长颈鹿\n"）;

elseif（b==110）

printf（”该动物是斑马\n"）；

else

printf（”该动物不存在\n”）;

system（”pause”）;

return0；

}

实验三:

子句消解

代码如下

＃include

＃include

h>

＃include〈string。

h>

＃include〈stdlib.h〉

＃defineN50

#defineM50

voidReplaceString（char＊Src,char*a,char＊b）

｛

char＊ptr;

intlen=strlen（Src）;

ptr=（char＊）malloc（sizeof（char）＊len+10）;

strcpy（ptr，Src）;

intsubLen_a=strlen（a）;

intsubLen_b=strlen（b）;

intj；intk=subLen_b-subLen_a；

for（inti=0;i〈len；i++）

｛

if（0==strncmp（＆ptr［i］,a，subLen_a））

{

for（j=i+subLen_a；j〈len；j++）

ptr［j+k]=ptr[j］;

strncpy（＆ptr[i]，b,subLen_b）；

｝

｝

ptr［len+k］='\0’；

strcpy（Src，ptr）;

｝

voidxiaojie（chara[］，charb[]）

｛

charA［N]［N],B[N]［N];

intn=0，m=0，i，j;

intlenth_a=strlen（a）,lenth_b=strlen（b）;

for（i=0；i

{

if（a[i］！

=’V'）

｛

A[n]［m]=a[i]；

m++;

}

else

｛

A［n］[m］='\0’;

m=0；

n++；

｝

}

A［n］［m］='\0’；

intk=n;//A的记录行数

n=0，m=0;

for（i=0;i

{

if（b［i]!

=’V'）

｛

B［n］［m]=b［i］；

m++;

｝

else

{

B［n]［m]='\0’；

m=0;

n++;

}

}

B［n］[m]='\0';

intr=n;//B的记录行数

//检查两子句是否含有互补对

for（n=0；n<=k;n++）

{

for（m=0;m<=r；m++）

｛

if（（B［m］[0]==’~’）＆&（B［m］[1］==A［n]［0]））//出现互补对

｛

//置换

charx［N］［N］,y[N]［N]；

intg=0,h=0;

lenth_a=strlen（A[n］）;

lenth_b=strlen（B[m］）；

for（i=2;i〈lenth_a-1；i++）

｛

if（A［n][i］！

=’,’）

{

x[g］［h］=A[n］[i];

h++；

｝

else

｛

x[g］［h］=’\0';

h=0；

g++；

｝

｝

x[g]［h]=’\0'；

g=0，h=0;

for（i=3；i〈lenth_b-1;i++）

{

if（B[n］[i]!

=’,’）

｛

y[g][h］=B[n]［i］;

h++;

｝

else

{

y［g］［h]='\0'；

h=0；

g++；

}

｝

y［g]［h]='\0’;

for（inti=0;i<=g；i++）//置换

{

if（strlen（x［i]）〉=strlen（y［i]））

｛

cout〈

for（j=0;j<=r；j++）

ReplaceString（B［j］,y［i］，x［i]）;

｝

if（strlen（x[i]）〈strlen（y[i］））

{

cout〈〈y[i]〈<"/"<

for（j=0；j〈=k；j++）

ReplaceString（A［j]，x[i],y［i］）;

｝

｝

for（i=n；i〈=k；i++）//消去互补对

strcpy（A[i］,A［i+1]）;

k=k—1;

for（i=m；i〈=r；i++）

strcpy（B[i],B[i+1］）；

r=r—1;

｝

elseif（（A［n]［0］=='～'）&＆（A[n］[1]==B[m][0］））

{

charx［N］［N］,y[N]［N］;

intg=0，h=0；

lenth_a=strlen（A［n］）;

lenth_b=strlen（B［m]）;

for（i=3;i〈lenth_a;i++）

{

if（A[n］［i]！

=’，'）

｛

x[g］［h］=A[n]［i］;

h++；

}

else

{

x［g]［h]=’\0’；

h=0；

g++；

}

}

x[g][h]='\0’；

g=0，h=0；

for（i=2;i

{

if（B[n][i］！

=’,’）

｛

y［g］[h］=B