人工智能课程设计报告罗马尼亚度假问题讲解Word格式.docx
《人工智能课程设计报告罗马尼亚度假问题讲解Word格式.docx》由会员分享，可在线阅读，更多相关《人工智能课程设计报告罗马尼亚度假问题讲解Word格式.docx（38页珍藏版）》请在冰豆网上搜索。
数据如下：
1、地图
2、启发函数值
Arad366Mehadia241Bucharest0Neamt234Craiova160Oradea380Doberta242
Pitesti100Eforie161Rimmicu_Vikea193Fagaras176Sibiu253Glurgiu77
Timisoara329Hirsova151Urziceni80Iasi226Vaslui199Lugoj244Zerind374
3、地图数据表
0100010001000100010001000100010001000100014010001181000100010001000100075
1000010001000100010007510001000100010001000100010001000100010001000701000
10001000010001000100010001011000100021110009010001000851000100010001000
100010001000010001000100010001000100010001000100010001000100087100010001000
10001000100010000100012013810001461000100010001000100010001000100010001000
10001000100010001000010001000100010001000151100010001000100010001000100071
10007510001000120100001000100010001000100010001000100010001000100010001000
1000100010110001381000100001000971000100010001000100010001000100010001000
100010001000100010001000100010000100010001000100010008610001000100010001000
100010001000100014610001000971000010008010001000100010001000100010001000
10001000211100010001000100010001000100009910001000100010001000100010001000
14010001000100010001511000100010008099010001000100010001000100010001000
100010009010001000100010001000100010001000100001000100010001000100010001000
118100010001000100010001000100010001000100010001000010001000100010001111000
1000100010001000100010001000100086100010001000100010000981000100010001000
1000100085100010001000100010001000100010001000100010009801000100010001000
1000100010008710001000100010001000100010001000100010001000100009210001000
100010001000100010001000100010001000100010001000100010001000100092010001000
10007010001000100010001000100010001000100010001000111100010001000100001000
7510001000100010007110001000100010001000100010001000100010001000100010000
二.设计分析
1.算法分析
1）宽度优先搜索算法
广度优先搜索使用队列（queue）来实现
1、把根节点放到队列的末尾。
2、每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。
并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个图还没有找到，结束程序。
2）深度优先搜索算法
深度优先搜索用栈（stack）来实现，整个过程可以想象成一个倒立的树形：
1、把根节点压入栈中。
2、每次从栈中弹出一个元素，搜索所有在它下一级的元素，把这些元素压入栈中。
4、如果遍历整个树还没有找到，结束程序。
3）贪婪算法
1.建立数学模型来描述问题
⒉把求解的问题分成若干个子问题。
⒊对每一子问题求解，得到子问题的局部最优解。
⒋把子问题的解局部最优解合成原来解问题的一个解。
实现该算法的过程：
从问题的某一初始解出发；
while能朝给定总目标前进一步
do
求出可行解的一个解元素；
由所有解元素组合成问题的一个可行解。
4）A*算法
A*[1]（A-Star）算法是一种静态路网中求解最短路最有效的直接搜索方法。
公式表示为：
f（n）=g（n）+h（n）,
其中f（n）是从初始点经由节点n到目标点的估价函数，
g（n）是在状态空间中从初始节点到n节点的实际代价，
h（n）是从n到目标节点最佳路径的估计代价。
保证找到最短路径（最优解的）条件，关键在于估价函数f（n）的选取：
估价值h（n）<
=n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。
但能得到最优解。
并且如果h（n）=d（n），即距离估计h（n）等于最短距离，那么搜索将严格沿着最短路径进行，此时的搜索效率是最高的。
如果估价值>
实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。
2.数据结构
1）图结构：
实现存储“罗马尼亚度假问题”的图空间；
抽象图结构的实现：
typedefstruct//图节点类型
{
charcityname[20];
intvalue;
intcost;
}Ver;
classGraph//图结构
public:
Graph（）;
~Graph（）;
VerV[MaxV];
intedge[MaxV][MaxV];
intnumofedges;
//注意这个变量的引用位置
//读取地图节点信息
voidReadVertex（）;
//读取地图边关系信息
voidReadEdge（）;
//取及第V个节点的第一个邻接点
intGetFirstVertex（intv）;
//找到第V1个节点的V2之后的下一个邻接节点
intGetNextVertex（intv1,intv2）;
intGetVerValue（intindex）;
//获取V[index]的ver的value值
intGetVerCost（intindex）;
//获取V[index]的ver的cost值
intGetEdge（introw,intcol）;
//获取edge[row][col]的值
voidSetVerCost（intindex,intcost）;
};
2）队列结构
宽度优先算法以及A*算法使用到。
抽象队列结构实现：
classSeqQueue
SeqQueue（）;
~SeqQueue（）;
voidQueueInitiate（）;
intQueueNotEmpty（）;
intQueueAppend（intx）;
intQueueDelete（int*d）;
intQueueOrderAppend（intx,Graph&
G）;
//A*算法使用
intQueue_A_OrderAppend（intx,Graph&
private:
intqueue[MaxSize];
intrear;
intfront;
intcount;
3）栈结构
深度优先算法使用；
栈结构的抽象类型实现：
classStack
Stack（）;
~Stack（）;
boolStackNotFull（）;
boolStakNotEmpty（）;
voidStackPop（Graph&
voidStackPush（intx,Graph&
voidPrintStack（Graph&
intGetWeight（）;
inta[100];
inttop1;
intweight;
三.算法设计
1）宽度优先搜索算法
//宽度优先算法
voidRomania_Trip:
:
BroadFirstSearch（Graph&
graph,intv）
intu,w;
i=0;
SeqCQuenequeue;
visited[v]=1;
//访问节点
count++;
if（v==end）return;
queue.QueueAppend（v）;
//入队列
while（queue.QueueNotEmpty（））//队列非空
{
queue.QueueDelete（&
u）;
//取队列节点
w=graph.GetFirstVertex（u）;
while（w!
=-1）//有子节点的话
{
if（!
visited[w]）//如果子节点未被访问，则访问子节点
{
Visit（w,u）;
visited[w]=1;
count++;
if（w==end）//找到结果
{
Print（graph,b,end,v）;
return;
}
queue.QueueAppend（w）;
//节点压入队列
}
w=graph.GetNextVertex（u,w）;
}
}
}
//深度优先算法
boolisOK=false;
intlevel=0;
constintLevel=8;
//预设的搜索层次
DepthFirstSearch（Graph&
graph,intv,Stack&
stack）
intw;
if（isOK==true）return;
if（level+1>
Level）return;
//大于搜索层次时不再深入
level++;
//访问该节点
stack.StackPush（v,graph）;
if（v==end||stack.GetWeight（）>
=MaxWeight）
w=-1;
if（v==end&
&
stack.GetWeight（）<
cout<
<
"
---深度优先遍历路径为：
"
;
stack.PrintStack（graph）;
/*if（MaxWeight>
stack.GetWeight（））
MaxWeight=stack.GetWeight（）;
*/
---路径长度为：
<
stack.GetWeight（）<
endl
<
---访问节点数为：
count<
endl
---搜索层次：
level<
endl;
isOK=true;
else
w=graph.GetFirstVertex（v）;
//取当前节点的第一个子节点
while（w!
=-1）
if（!
visited[w]）
DepthFirstSearch（graph,w,stack）;
//递归访问
w=graph.GetNextVertex（v,w）;
//取当前节点的下一个子节点
visited[v]=0;
//返回时置该节点为未访问
stack.StackPop（graph）;
//将该节点弹出栈，并根据graph中weight的值更改当前栈值
level--;
//贪婪算法
Greedy_Algorithms（Graph&
//队列存储图节点在图中的索引值,优先队列，value小的在队头
if（v==end）{return;
queue.QueueOrderAppend（v,graph）;
//图节点按优先顺序入队列
//访问节点数+1
while（queue.QueueNotEmpty（））//宽度优先，循环
queue.QueueDelete（&
//删除队列头元素并返回删除的数值
//cout<
u="
u<
w=graph.GetFirstVertex（u）;
//访问w节点，将wayb的指向更新
if（w==end）
{
//cout<
w==end"
count++;
queue.QueueOrderAppend（w,graph）;
//图节点按优先顺序入队列
}4）A*算法
//A*算法
AStar_Algorithms（Graph&
//i=0;
count=0;
if（v==end）return;
//到达终点
queue.Queue_A_OrderAppend（v,graph）;
while（queue.QueueNotEmpty（））
if（u==end）
graph.GetVerCost（u）+graph.GetVerValue（u）<
endl;
return;
intcost=graph.GetVerCost（u）+graph.GetEdge（w,u）;
graph.SetVerCost（w,cost）;
//设置当前节点移动到目标节点的预估费用
queue.Queue_A_OrderAppend（w,graph）;
//按预估费用优先入队列
count++;
四.运行结果及分析
分析：
节点数
路径长度
耗时ms
Optimality:
Completeness:
BFS
11
450
16
No
YES
DFS
12
605
31
NO
Greedy
8
A*算法
418
通过比较，Greedy搜索生成的结点数目最少，为8个，效率最高；
A*算法生成的结点数目最多，为30个，效率最低。
DFS（一般）、BFS和Greedy搜索找到的都不一定最优解，A*算法具有完备性且始终找到的是最优解。
宽度优先虽然是完备的（如果分支因子有限的话），在任何情况下宽度优先都能找到一个解，但是，它找到的第一个解并非最优的，此外，最坏的情况是，当目标结点是第d层的最后一个被扩展的结点时，它将耗费大量的时间。
宽度优先时间复杂度：
（b为分支因子，d为深度）；
空间复杂度为所存储的节点的个数。
DFS不是完备的（除非查找空间是有限的），同时，它也不能找到最优解。
深度优先的时间复杂度：
；
空间复杂度：
（b为分支因子，m为深度，仅有一枝需要存储）；
。
贪婪算法不是完备的。
同时，它找到的解也不一定是最优解。
其时间复杂度：
（b代表分支数，m为深度）；
空间复杂度为
）。
所以只有A*算法和DFS（回溯+剪枝）是完备的，且能够找到最优解；
扩展节点的数目；
所有生成的结点。
综合来看，BFS和贪婪算法的效率较高，但解并非最优，而A*算法的效率稍逊色，但解为最优；
DFS（回溯+剪枝）搜索虽能找到最优解但效率最低。
源代码
//Graph.h
#pragmaonce
usingnamespacestd;
#defineMaxV20
/*#ifndefMY_DEBUG
#defineMY_DEBUG
#endif*/
typedefstruct
//城市名
//权值
//A*算法中从当前节点移动到目标节点的预估费用
classGraph
//获取V[index]的v
升级会员 