中南民族大学人工智能导论实验报告.docx
《中南民族大学人工智能导论实验报告.docx》由会员分享，可在线阅读，更多相关《中南民族大学人工智能导论实验报告.docx（29页珍藏版）》请在冰豆网上搜索。
中南民族大学人工智能导论实验报告
院系：
计算机科学学院
专业：
xxx
年级：
xxx级
课程名称：
人工智能导论
学号：
xxx
姓名：
xxx
指导教师:
2013年12月1日
年级
xxx级
xxx
学号
xxx
专业
xxx
姓名
xxx
实验名称
水壶问题
实验
类型
设计型
综合型
创新型
√
实
验
目
的
或
要
求
给定A，B两个个水壶，一个最终状态C，其中水壶A的容量为V_A,水壶B的容量为V_B，求是否可以通过水壶A和B，使得最终A或B中水的体积为C
实
验
原
理
（
算
法
流
程
）
约定有6中操作，并分别记为操作号1，2,3,4,5,6
1.FILL（A）将A壶装满
2.FILL（B）将B壶装满
3.Empty（A）将A壶中的水倒空
4.Empty（B）将B壶中的水倒空
5.Pour（A,B）将水从A壶倒到B壶
6.Pour（B,A）将水从B壶倒到A壶
A，B壶的初始状态为空，显然这是一颗六叉树，并且这不是一颗完整的六叉树，因为有一些节点并不符合，对于不合法的节点，将它剪掉（剪枝操作）
广度优先搜索（BFS）：
（1）将首节点（0,0）入队
（2）队列不为空循环
[2.1]队首节点出队，判断A,B壶中是否至少有一个达到C状态
[2.2]对于6种操作，每个父节点产生6个新的节点，将合法的节点入队，不和法的节点剪掉
（3）如果有可行解，打印可行解
组
内
分
工
（
可
选
）
实
验
结
果
分
析
及
心
得
体
会
运行结果截图：
成
绩
评
定
教师签名：
2013年月日
备注：
源代码附后，源代码要求有注释说明
代码：
#include
#include
#include
#include
#include
#defineM1000
intvis[M+5][M+5];
intaNum,bNum,cNum;
structNode/*状态节点*/
{
intx;
inty;
intstep;
};
structparent/*记忆表*/
{
intpx;
intpy;
}prev[M+5][M+5];
voiddfs（intx,inty）
{
if（prev[x][y].px+prev[x][y].py!
=0）
{
dfs（prev[x][y].px,prev[x][y].py）;
}/*EndofIf*/
intprex=prev[x][y].px;
intprey=prev[x][y].py;
/*Fill（A）*/
if（prex!
=aNum&&x==aNum&&y==prey）
{
printf（"Fill（A）\n"）;
return;
}
/*Fill（B）*/
if（prey!
=bNum&&y==bNum&&x==prex）
{
printf（"Fill（B）\n"）;
return;
}
/*Empty（A）*/
if（prex!
=0&&x==0&&y==prey）
{
printf（"Empty（A）\n"）;
return;
}
/*Empty（B）*/
if（prey!
=0&&y==0&&x==prex）
{
printf（"Empty（B）\n"）;
return;
}
/*Pour（A,B）orPour（B,A）*/
if（prex+prey==x+y）
{/*倒水前后总水量不变*/
if（x==0||y==bNum）
{
printf（"Pour（A,B）\n"）;
}
else
{
printf（"Pour（B,A）\n"）;
}
return;
}
}/*dfs*/
voidBFS（）
{
intIsSolve=0;/*问题求解标志，初始时问题未被求解*/
intrear=-1;/*队列尾指针*/
intfront=-1;/*队首指针*/
Nodecur,next;
Nodequeue[M+10]={0};
cur.x=0;/*当前水壶A状态*/
cur.y=0;/*当前水壶B状态*/
cur.step=0;/*记录当前步数*/
queue[++rear]=cur;/*初始状态入队*/
vis[0][0]=1;/*初始状态设为已被访问*/
while（front!
=rear）
{/*队列不为空时循环*/
cur=queue[++front];
if（cur.x==cNum||cur.y==cNum）
{
IsSolve=1;
printf（"TotalStep:
%d\n",cur.step）;
dfs（cur.x,cur.y）;/*dfs回溯打印可行方案*/
break;
}/*EndofIf*/
/*operationstepaddone*/
next.step=cur.step+1;
/*OP1:
Fill（A）*/
next.x=aNum;
next.y=cur.y;
if（!
vis[next.x][next.y]）
{
vis[next.x][next.y]=1;
prev[next.x][next.y].px=cur.x;/*记忆表的实现*/
prev[next.x][next.y].py=cur.y;
queue[++rear]=next;
}
/*OP2:
Fill（B）*/
next.x=cur.x;
next.y=bNum;
if（!
vis[next.x][next.y]）
{
vis[next.x][next.y]=1;
prev[next.x][next.y].px=cur.x;
prev[next.x][next.y].py=cur.y;
queue[++rear]=next;
}
/*OP3:
Empty（A）*/
next.x=0;
next.y=cur.y;
if（!
vis[next.x][next.y]）
{
vis[next.x][next.y]=1;
prev[next.x][next.y].px=cur.x;
prev[next.x][next.y].py=cur.y;
queue[++rear]=next;
}
/*OP4:
Empty（B）*/
next.x=cur.x;
next.y=0;
if（!
vis[next.x][next.y]）
{
vis[next.x][next.y]=1;
prev[next.x][next.y].px=cur.x;
prev[next.x][next.y].py=cur.y;
queue[++rear]=next;
}
/*OP5:
Pour（A,B）*/
next.y=（cur.x+cur.y）（cur.x+cur.y）:
bNum;
next.x=cur.x-（next.y-cur.y）;
if（!
vis[next.x][next.y]）
{
vis[next.x][next.y]=1;
prev[next.x][next.y].px=cur.x;
prev[next.x][next.y].py=cur.y;
queue[++rear]=next;
}
/*OP6:
Pour（B,A）*/
next.x=（cur.x+cur.y）（cur.x+cur.y）:
aNum;
next.y=cur.y-（next.x-cur.x）;
if（!
vis[next.x][next.y]）
{
vis[next.x][next.y]=1;
prev[next.x][next.y].px=cur.x;
prev[next.x][next.y].py=cur.y;
queue[++rear]=next;
}
}/*EndofWhile*/
if（!
IsSolve）
{
printf（"NoSolution.\n"）;
}
}/*BFS*/
intmain（）
{
while（~scanf（"%d%d%d",&aNum,&bNum,&cNum））
{
/*Resetthearray*/
memset（vis,0,sizeof（vis））;
memset（prev,0,sizeof（prev））;
BFS（）;/*利用广度优先搜索找出所有可能解*/
}/*EndofWhile*/
return0;
}
年级
xxx级
xxx
学号
xxx
专业
xxx
姓名
xxx
实验名称
传教士过河问题
实验
类型
设计型
综合型
创新型
√
实
验
目
的
或
要
求
有N个传教士，M个野人，现在有一条可以载K个人的船（K要求在任何时刻，河的两岸以及船上的野人树不多于传教士人数，否则传教士就会被野人吃掉，要求求出可行的运输方案
实
验
原
理
（
算
法
流
程
）
约定0表示船在左岸，1表示船在右岸，初始状态为野人，船和传教士都在左岸，那么可以构造一颗广度优先树，野人，船和传教士的状态就是相对应的一个节点，显然有些节点是不符合的，同样也需要剪枝，具体的方法是根据船的位置，对左岸或右岸进行广度优先搜索
广度优先搜索：
（1）初始节点入队
（2）队列不为空循环
[1]队首节点出队，判断是否已经到达目的状态
[2]根据船的位置对左岸或右岸进行枚举，检查枚举过程的节点是否合法，如果合法则入队，否则剪掉
（3）输出可行的方案数
组
内
分
工
（
可
选
）
实
验
结
果
分
析
及
心
得
体
会
结果截图：
成
绩
评
定
教师签名：
2013年月日
备注：
源代码附后，源代码要求有注释说明
源代码：
#include
#include
#include
#include
#defineN1000
#defineM1000
//#definelocaljudge
inthash[N+5][M+5][2];/*hash判重*/
intnNum,mNum,kNum;/*N个传教士，M个野人，船一次能载K人*/
structNode
{
intleftMiss;/*左岸的传教士人数*/
intleftSava;/*左岸的野人数*/
intstep;/*记录移动步数*/
intboat;/*表示船的位置，0代表左岸，1代表右岸*/
}queue[N*M+5];
structparent
{
intpx;
intpy;
intboat;
}prev[N+5][M+5][2];/*记录移动路径*/
intIsLegal（intleftMiss,intleftSava,intboatMiss,intboatSava,intrightMiss,intrightSava）
{
if（leftMiss<0||leftSava<0||leftMiss>nNum||leftSava>mNum）
{
return0;
}
if（rightMiss<0||rightSava<0||rightMiss>nNum||rightSava>mNum）
{
return0;
}
if（（leftMiss&&leftMiss||（rightMiss&&rightMiss{
return0;
}
return1;
}/*IsInBound*/
voiddfs（intleftMiss,intleftSava,intboat）
{
if（prev[leftMiss][leftSava][boat].px!
=nNum
&&prev[leftMiss][leftSava][boat].py!
=mNum
&&prev[leftMiss][leftSava][boat].boat）
{
dfs（prev[leftMiss][leftSava][boat].px,
prev[leftMiss][leftSava][boat].py,
prev[leftMiss][leftSava][boat].boat）;
}/*EndofIf*/
printf（"%d%d|%d%d\n",leftMiss,leftSava,nNum-leftMiss,mNum-leftSava）;
return;
}/*dfs*/
voidbfs（）
{
intIsSolve=0;/*描述问题求解的状态*/
intrear=-1;
intfront=-1;
inti,j,rightMiss,rightSava;
structNodecur={0},next={0};
cur.leftMiss=nNum;/*左岸传教士初始为N人*/
cur.leftSava=mNum;/*左岸野人初始为M人*/
cur.step=cur.boat=0;/*初始移动步数为0，船在左岸*/
queue[++rear]=cur;/*初始状态入队*/
hash[cur.leftMiss][cur.leftSava][cur.boat]=1;/*初始状态设为已被访问*/
while（front{
cur=queue[++front];/*获得队首状态节点*/
if（cur.leftMiss==0&&cur.leftSava==0&&cur.boat==1）
{
IsSolve=1;/*问题已被求解*/
printf（"Step:
%d\n",cur.step）;
//printf（"%d%d|00\n",nNum,mNum）;
//dfs（cur.leftMiss,cur.leftSava,cur.boat）;
break;
}/*EndofIf*/
rightMiss=nNum-cur.leftMiss;
rightSava=mNum-cur.leftSava;
if（cur.boat==0）
{/*船在左岸*/
for（i=0;i<=cur.leftMiss&&i<=kNum;++i）
{
for（j=0;j<=cur.leftSava&&i+j<=kNum;++j）
{
if（i+j==0）
continue;
next.leftMiss=cur.leftMiss-i;/*左岸教士减少i人*/
next.leftSava=cur.leftSava-j;/*左岸野人减少j人*/
next.boat=1-cur.boat;/*改变船的状态*/
if（!
hash[next.leftMiss][next.leftSava][next.boat]
&&IsLegal（next.leftMiss,next.leftSava,i,j,rightMiss+i,rightSava+j））
{
/*移动步数增加一*/
next.step=cur.step+1;
/*设为已被访问*/
hash[next.leftMiss][next.leftSava][next.boat]=1;
/*记录父节点左岸教士数*/
prev[next.leftMiss][next.leftSava][next.boat].px=cur.leftMiss;
/*记录父节点左岸野人数*/
prev[next.leftMiss][next.leftSava][next.boat].py=cur.leftSava;
/*记录父节点船的状态*/
prev[next.leftMiss][next.leftSava][next.boat].boat=cur.boat;
queue[++rear]=next;/*当前可行的运输方案入队*/
}
}/*Endoffor*/
}/*EndofFor*/
}/*EndofIf*/
else
{/*船在右岸*/
for（i=0;i<=rightMiss&&i<=kNum;++i）
{
for（j=0;j<=rightSava&&i+j<=kNum;++j）
{
if（i+j==0）
continue;
next.leftMiss=cur.leftMiss+i;/*左岸教士增加i人*/
next.leftSava=cur.leftSava+j;/*左岸野人增加j人*/
next.boat=1-cur.boat;/*改变船的状态*/
if（!
hash[next.leftMiss][next.leftSava][next.boat]
&&IsLegal（next.leftMiss,next.leftSava,i,j,rightMiss-i,rightSava-j））
{
/*移动步数增加一*/
next.step=cur.step+1;
/*设为已被访问*/
hash[next.leftMiss][next.leftSava][next.boat]=1;
/*记录父节点左岸教士数*/
prev[next.leftMiss][next.leftSava][next.boat].px=cur.leftMiss;
/*记录父节点左岸野人数*/
prev[next.leftMiss][next.leftSava][next.boat].py=cur.leftSava;
/*记录父节点船的状态*/
prev[next.leftMiss][next.leftSava][next.boat].boat=cur.boat;
queue[++rear]=next;/*当前可行的运输方案入队*/
}
}/*Endoffor*/
}/*EndofFor*/
}/*EndofElse*/
}/*EndofWhile*/
if（!
IsSolve）
{
printf（"NoSolution.\n"）;
}
}/*bfs*/
intmain（）
{
#ifdeflocaljudge
freopen（"E:
\\Miss_Sava.txt","r",stdin）;
freopen（"E:
\\Miss_Sava（result）.txt","w",stdout）;
#endif
while（~scanf（"%d%d%d",&nNum,&mNum,&kNum））
{
/*Emptythearray*/
memset（hash,0,sizeof（hash））;
memset（prev,0,sizeof（prev））;
memset（queue,0,sizeof（queue））;
bfs（）;
}/*EndofWhile*/
return0;
}
年级
xxx级
xxx
学号
xxx
专业
xxx
姓名
xxx
实验名称
演化算法
实验
类型
设计型
综合型
创新型
√
实
验
目
的
或
要
求
给定方程y=10*sin（5*x）+7*cos（4*x），求方程在[1,20]的最大值，以及取得最大值的x值
实
验
原
理
（
算
法
流
程
）
演化算法（遗传算法）：
（1）初始化种群的范围是[1,20]，对于每个个体x，求出y
（2）在[1,20]中任意选择两个x坐标，做仿射变换得到一个新的x坐标，记为x1
（3）将通过仿射变换得到的x1代入方程y=10*sin（5*x）+7*cos（4*x）求出一个y1
（4）比较y1和y的值，筛选掉值少的一个，y保存更接近最优解的一个值
算法的思想是动态逼近法，通过枚举x坐标，作仿射变换得到x1，求出y1值，然后用y1与y比较，筛选掉值小者，每次枚举都得到一个接近最优解的x，y坐标，迭代的次数大概在250–1000就基本可以确定最优解
组
内
分
工
（
可
选
）
升级会员 