人工智能实验一Word文档下载推荐.docx
《人工智能实验一Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《人工智能实验一Word文档下载推荐.docx（23页珍藏版）》请在冰豆网上搜索。
（1）复习程序设计和数据结构课程的相关知识；
（2）熟悉人工智能系统中的问题求解过程；
（3）熟悉对八码数问题的建模、求解及编程语言的运用。
二、实验原理及基本技术路线图（方框原理图或程序流程图）
（1）建立一个只含有起始节点S的搜索图G，把S放到一个叫做OPEN的未扩展节点的表中；
（2）建立一个叫做CLOSED的已扩展节点表，其初始为空表；
（3）LOOP:
若OPEN表是空表，则失败退出；
（4）选择OPEN表上的第一个节点，把它从OPEN表移除并放进CLOSED表中，称此节点为节点n；
（5）若n为一目标节点，则有解并成功退出，此解是追踪图G中沿着指针从n到S这条路径而得到的；
（6）扩展节点n，同时生成不是n的祖先的那些后继节点的集合M。
把M的这些成员作为n的后继节点舔到图中；
（7）对那些未曾在G中出现过的M成员设置一个通向n的指针。
把M的这些成员加进OPEN表。
对已经在OPEN表或CLOSED表上的成员，确定是否需要更改通到n的指针方向；
（8）按某一任意方式或按某个探视值，重排OPEN表。
宽度优先算法实现过程
（1）把起始节点放到OPEN表中；
（2）如果OPEN是个空表，则没有解，失败退出；
否则继续；
（3）把第一个节点从OPEN表中移除，并把它放入CLOSED的扩展节点表中；
（4）扩展节点n。
如果没有后继节点，则转向
（2）；
（5）把n的所有后继结点放到OPEN表末端，并提供从这些后继结点回到n的指针；
（6）如果n的任意一个后继结点是目标节点，则找到一个解答，成功退出，否则转
（2）。
深度优先实现过程
（1）把起始节点S放入未扩展节点OPEN表中。
如果此节点为一目标节点，则得一个解；
（2）如果OPEN为一空表，则失败退出；
（3）把第一个节点从OPEN表移到CLOSED表；
（4）如果节点n的深度等于最大深度，则转向
（2）；
（5）扩展节点n，产生其全部后裔，并把它们放入OPEN表的前头。
如果没有后裔，则转向
（2）；
（6）如果后继结点中有任一个目标节点，则得到一个解，成功退出，否则转向
（2）。
三、所用仪器、材料（设备名称、型号、规格等或使用软件）
1台PC及VISUALC++6.0软件
四、实验方法、步骤（或：
程序代码或操作过程）
1、先创建项目，新建SourceFile文件：
main.cpp。
#include<
iostream>
#include"
Node.h"
Queue.h"
Search.h"
Tree.h"
voidCreateNode1（std:
:
vector<
int>
&
s）
{
s.push_back
（2）;
s.push_back（8）;
s.push_back（3）;
s.push_back
（1）;
s.push_back（0）;
s.push_back（4）;
s.push_back（7）;
s.push_back（6）;
s.push_back（5）;
}
voidCreateNode4（std:
d）
d.push_back
（2）;
d.push_back（8）;
d.push_back（3）;
d.push_back
（1）;
d.push_back（6）;
d.push_back（4）;
d.push_back（7）;
d.push_back（0）;
d.push_back（5）;
voidCreateNode8（std:
voidCreateNode20（std:
voidCreateNode27（std:
voidCreateNode_test1（std:
voidtest_expand（）
std:
s;
CreateNode1（s）;
d;
CreateNode4（d）;
Nodesource（s）;
Nodedest（d）;
source.Display（）;
Searchsearch（&
source）;
cout<
<
source.Expand（dest,search）;
voidtest_search（）
dest.Display（）;
search.Find（&
dest）;
search.DisplayRoute（）;
voidtest_search2level（）
CreateNode8（d）;
voidtest_search_lab1（）
CreateNode27（d）;
intmain（intargc,char**argv）
//test_expand（）;
//test_search（）;
//test_search2level（）;
//test_search_lab1（）;
return0;
2、新建SourceFile文件：
Node.cpp。
#ifndefPROGECT_1_NODE
#definePROGECT_1_NODE
vector>
enumOP
EMPTY,
UP,
DOWN,
LEFT,
RIGHT
};
boolIsOpposite（OPopa,OPopb）;
classNode
public:
Node（std:
const&
state）;
boolExpand（Nodeconst&
destNode,Search&
search）;
voidDisplay（）const;
voidDisplayRoute（）const;
booloperator==（Nodeconst&
v）const;
private:
Node*CreateChild（OPop）;
intFindEmptySpaceId（）const;
OP>
GenerateLegalOperators（intspaceId）const;
intCalIdBasedOP（OPop,intspaceId）const;
boolIsWithinRange（OPop,intspaceId）const;
m_state;
Node*m_pParent;
Node*>
m_children;
OPm_op;
#endif//PROGECT_1_NODE
3新建HeardFile文件：
node.h。
math.h>
boolIsOpposite（OPopa,OPopb）
if（LEFT==opa&
RIGHT==opb）
returntrue;
if（RIGHT==opa&
LEFT==opb）
if（UP==opa&
DOWN==opb）
if（DOWN==opa&
UP==opb）
returnfalse;
Node:
Node（std:
state）
m_state（state）
m_pParent（NULL）
m_children（）
m_op（EMPTY）
voidShowOP（OPop）
switch（op）
{
caseEMPTY:
std:
"
EMPTY"
;
break;
caseUP:
UP"
caseDOWN:
DOWN"
caseLEFT:
LEFT"
caseRIGHT:
RIGHT"
default:
exit（-1）;
}
voidShowOPs（std:
ops）
for（intid=0;
id<
ops.size（）;
++id）
ShowOP（ops[id]）;
endl;
boolNode:
Expand（Nodeconst&
search）
intspaceId=FindEmptySpaceId（）;
spaceisat"
<
spaceId<
legalOPs=GenerateLegalOperators（spaceId）;
ShowOPs（legalOPs）;
while（legalOPs.size（）>
0）
OPop=legalOPs[legalOPs.size（）-1];
legalOPs.pop_back（）;
Node*pChild=CreateChild（op）;
if（*pChild==destNode）
{
search.SetDestPt（pChild）;
returntrue;
}
search.GetQueue（）.EnQueue（pChild）;
voidNode:
Display（）const
for（inti=0;
i<
m_state.size（）;
++i）
m_state[i]<
pParent:
m_pParent<
op:
ShowOP（m_op）;
for（intj=0;
j<
m_children.size（）;
++j）
m_children[j]<
DisplayRoute（）const
routeOps;
Nodeconst*pNode=this;
while（NULL!
=pNode）
routeOps.push_back（pNode->
m_op）;
pNode=pNode->
m_pParent;
for（intid=routeOps.size（）-2;
id>
=0;
--id）
ShowOP（routeOps[id]）;
operator==（Nodeconst&
v）const
++id）
if（m_state[id]!
=v.m_state[id]）
returnfalse;
returntrue;
Node*Node:
CreateChild（OPop）
childState=m_state;
intexchangePos1=FindEmptySpaceId（）;
intexchangePos2=CalIdBasedOP（op,exchangePos1）;
inttemp=childState[exchangePos1];
childState[exchangePos1]=childState[exchangePos2];
childState[exchangePos2]=temp;
Node*child=newNode（childState）;
child->
m_pParent=this;
m_op=op;
m_children.push_back（child）;
returnchild;
intNode:
FindEmptySpaceId（）const
if（0==m_state[id]）
returnid;
return-1;
std:
Node:
GenerateLegalOperators（intspaceId）const
allPossibleOps;
allPossibleOps.push_back（UP）;
allPossibleOps.push_back（DOWN）;
allPossibleOps.push_back（LEFT）;
allPossibleOps.push_back（RIGHT）;
ops;
allPossibleOps.size（）;
OPop=allPossibleOps[id];
if（IsOpposite（op,m_op））
continue;
if（IsWithinRange（op,spaceId））
ops.push_back（op）;
returnops;
CalIdBasedOP（OPop,intspaceId）const
spaceId-=int（sqrt（m_state.size（）））;
spaceId+=int（sqrt（m_state.size（）））;
--spaceId;
++spaceId;
return-1;
returnspaceId;
IsWithinRange（OPop,intspaceId）const
spaceId=CalIdBasedOP（op,spaceId）;
if（spaceId>
=0&
m_state.size（））
4、新建SourceFile文件：
Queue.cpp。
voidQueue:
EnQueue（Node*pNode）
m_queue.push_back（pNode）;
Node*Queue:
DeQueue（）
if（m_queue.size（）==0）
returnNULL;
Node*pNode=m_queue[0];
m_queue.pop_front（）;
returnpNode;
5、新建HeardFile文件：
Queue.h。
#ifndefPROGECT_1_QUEUE
#definePROGECT_1_QUEUE
deque>
classNode;
classQueue
voidEnQueue（Node*pNode）;
Node*DeQueue（）;
deque<
m_queue;
#endif//PROGECT_1_QUEUE
6、新建SourceFile文件：
Search.cpp。
Search:
Search（Node*root）
m_queue（）
m_pDestNode（NULL）
m_queue.EnQueue（root）;
Node*Search:
Select（）
returnm_queue.DeQueue（）;
voidSearch:
Find（Node*destNode）
boolisFound=false;
while（!
isFound）
Node*pNode=Select（）;
pNode->
Display（）;
isFound=pNode->
Expand（*destNode,*this）;
m_pDestNode->
DisplayRoute（
升级会员 