人工智能实验一Word文件下载.docx
- 文档编号:16969485
- 上传时间:2022-11-27
- 格式:DOCX
- 页数:15
- 大小:256.47KB
人工智能实验一Word文件下载.docx
《人工智能实验一Word文件下载.docx》由会员分享,可在线阅读,更多相关《人工智能实验一Word文件下载.docx(15页珍藏版)》请在冰豆网上搜索。
intresult;
intxiabiao[]=null;
//访问的下标
Publicstaticvoidmain(String[]args){
Graphgraph=newGraph();
System.out.println("
----------------罗马尼亚问题---------------"
);
1、深度优先搜索"
DFSdfs=newDFS();
dfs.DF_Search(graph,0,12);
2、迭代加深的搜索"
IDSids=newIDS();
ids.IDS_Search(graph,0,12,15);
//深度设15
3、一致代价搜索"
UCSucs=newUCS(graph,0,12);
4、A*搜索"
AXingaXing=newAXing();
aXing.A_Search(graph,graph.H,0,15);
//0-15即Arad到达Hirsova
}
Publicvoidshow(Graphg,Stackstack){//打印
if(stack.size()==0){
路径搜索失败"
return;
result=0;
System.out.print("
访问的下标:
"
for(inti=0;
i<
stack.size();
i++){
-->
"
+stack.get(i));
\n访问过程:
xiabiao=newint[stack.size()];
if(stack.isEmpty()){
搜索失败"
}else{
+g.cities[(Integer)stack.get(i)]);
stack.size()-1;
result+=g.path[(Integer)stack.get(i)][(Integer)stack.get(i+1)];
\n总长度为:
+result+"
\n"
g.markInit();
//清空访问
PublicclassGraph{//数组存储图
Publicintpath[][]=newint[][]{{0,75,M,118,140,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M},
{75,0,71,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M},
{M,71,0,M,151,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M},
{118,M,M,0,M,111,M,M,M,M,M,M,M,M,M,M,M,M,M,M},
{140,M,151,M,0,M,80,99,M,M,M,M,M,M,M,M,M,M,M,M},
{M,M,M,111,M,0,M,M,70,M,M,M,M,M,M,M,M,M,M,M},
{M,M,M,M,80,M,M,M,M,146,97,M,M,M,M,M,M,M,M},
{M,M,M,M,99,M,M,0,M,M,M,M,211,M,M,M,M,M,M,M},
{M,M,M,M,M,70,M,M,0,75,M,M,M,M,M,M,M,M,M,M},
{M,M,M,M,M,M,M,M,75,0,120,M,M,M,M,M,M,M,M,M},
{M,M,M,M,M,M,146,M,M,120,0,138,M,M,M,M,M,M,M,M},
{M,M,M,M,M,M,97,M,M,M,138,0,101,M,M,M,M,M,M,M},
{M,M,M,M,M,M,M,211,M,M,M,101,0,90,85,M,M,M,M,M},
{M,M,M,M,M,M,M,M,M,M,M,M,90,0,M,M,M,M,M,M},
{M,M,M,M,M,M,M,M,M,M,M,M,85,M,0,98,M,142,M,M},
{M,M,M,M,M,M,M,M,M,M,M,M,M,M,98,0,86,M,M,M},
{M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,86,0,M,M,M},
{M,M,M,M,M,M,M,M,M,M,M,M,M,M,142,M,M,0,92,M},
{M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,92,0,87},
{M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,87,0}};
Publicint[]H=newint[]{516,524,530,479,403,394,343,326,391,392,310,160,150,155,100,0};
//启发式函数
PublicString[]cities=newString[]{"
Arad"
"
Zerind"
Oradea"
Timisoara"
Sibiu"
Lugoj"
RimnicuVilcea"
Fagaras"
Mehadia"
Drobeta"
Craiova"
Pitesti"
Bucharest"
Giurgiu"
Urziceni"
Hirsova"
Eforie"
Vaslui"
Isi"
Neamt"
};
//城市名
Publicint[]mark=newint[20];
//访问标记
PublicGraph(){//得到数据
markInit();
//访问标志初始化
PublicvoidmarkInit(){
mark.length;
mark[i]=0;
PublicintgetFirstVex(intstart){//第一个孩子,return-1表示一个孩子都没有
if(start>
=0&
&
start<
path.length){
for(intj=0;
j<
path.length;
j++)
if(path[start][j]<
M&
path[start][j]>
0)//有关系
returnj;
return-1;
PublicintgetNextVex(intstart,intw){//下一个孩子
path.length&
w>
w<
for(inti=w+1;
i++)//w表示图G中顶点i的第j个邻接顶点的下一个邻接顶点
if(path[start][i]<
path[start][i]>
0)
returni;
//返回-1,表示后面没有邻接点了
PublicintgetNumber(){
returnpath.length;
(1)深度优先
基本原理:
深度优先搜索采用堆栈寻找路径,首先从Arad结点出发,判断是否为目标结点,若否,寻找与该结点的邻接点,先搜索一条分支上的所有节点,然后再去搜索和Arad的其它分支结点,找出并存进待扩展结点表,等待扩展,每次先判断待扩展结点表是否为空,若否,则从待扩展结点表中取出一个结点进行扩展,并将扩展后的结点存进该表,若是,则返回失败。
PublicclassDFS{//深度优先搜索类
Stackstack=newStack<
Integer>
();
intx;
intw;
//v0的第一个邻接点
PublicvoidDF_Search(Graphg,intv0,intvg){//深度优先搜索--非递归式
//g:
图v0:
开始节点vg:
最终节点
stack.push(v0);
//入栈
g.mark[v0]=1;
//v0被访问
while(true){
x=(Integer)stack.peek();
//查看栈顶元素
w=g.getFirstVex(x);
while(g.mark[w]==1){//被访问,则寻找下一个邻接点
w=g.getNextVex(x,w);
if(w==-1){
break;
while(w==-1){//没有找到下一个邻接点
stack.pop();
x=(Integer)stack.peek();
w=g.getFirstVex(x);
while(g.mark[w]==1){
w=g.getNextVex(x,w);
stack.push(w);
g.mark[w]=1;
if(w==vg)break;
//到达终点
NewMain().show(g,stack);
(2)一致代价
扩展的是路径消耗g(n)最小的节点n,用优先队列来实现,对解的路径步数不关心,只关心路径总代价。
即使找到目标节点也不会结束,而是再检查新路径是不是要比老路径好,确实好,则丢弃老路径。
PublicclassUCS{//一致代价类
publicUCS(Graphg,intstart,intend){
int[]pre=newint[20];
//保存各个结点的前驱结点
int[]dist=newint[20];
//用于保存当前结点到起始结点的实际路径长度
pre.length;
i++)
{
pre[i]=-1;
dist[i]=M;
//调用一致搜索算法搜索路径
UC_search(g,start,end,dist,pre);
//打印路径显示函数
displayPath(start,end,pre,g);
PublicvoiddisplayPath(intstart,intgoal,int[]prev,Graphg)//prev前驱节点
Stack<
stack=newStack<
stack.push(goal);
while(prev[goal]!
=start)
stack.push(prev[goal]);
goal=prev[goal];
stack.push(start);
访问的下标:
for(inti=stack.size()-1;
i>
=0;
i--){
\n访问过程:
+g.cities[stack.get(i)]);
intresult=0;
result+=g.path[stack.get(i)][stack.get(i+1)];
System.out.print(result);
g.markInit();
PublicvoidUC_search(Graphg,intstart,intgoal,int[]dist,int[]pre)
List<
list=newArrayList<
list.add(start);
while(!
list.isEmpty())
moveMinToTop(list,dist);
//将dist数组中最小值所对应的结点,移至list队首
intcurrent=list.remove(0);
//将list队首的结点出队,并展开
g.mark[current]=1;
if(current==goal)
g.path[current].length;
if(g.path[current][j]<
g.mark[j]==0)
if(!
isInList(j,list))//结点j不在队列里
list.add(j);
pre[j]=current;
dist[j]=dist[current]+g.path[current][j];
Elseif((dist[current]+g.path[current][j])<
dist[j])
pre[j]=current;
dist[j]=dist[current]+g.path[current][j];
if(list.isEmpty())
搜索不成功!
PublicbooleanisInList(inta,List<
list)//检查结点a,是否在队列list里
list.size();
if(list.get(i)==a)
Returntrue;
Returnfalse;
PublicvoidmoveMinToTop(List<
list,int[]dist)//将dist数组中的最小值所对//应的结点,从list队列中移至队列头
intindex=0;
intmin=dist[index];
inta=list.get(i);
if(dist[a]<
min)
index=i;
min=dist[a];
inttemp=list.get(index);
for(inti=index;
0;
i--)
list.set(i,list.get(i-1));
list.set(0,temp);
(3)A*搜索
公式表示为:
f(n)=g(n)+h(n),
其中
f(n)
是从初始点经由节点n到目标点的估价函数,
g(n)
是在状态空间中从初始节点到n节点的实际代价,
h(n)
是从n到目标节点最佳路径的估计代价。
保证找到最短路径(最优解的)条件,关键在于估价函数f(n)的选取:
首先将起始结点S放入OPEN表,CLOSE表置空,算法开始时:
1、如果OPEN表不为空,从表头取一个结点n,如果为空算法失败。
2、n是目标解吗?
是,找到一个解(继续寻找,或终止算法)。
3、将n的所有后继结点展开,就是从n可以直接关联的结点(子结点),如果不在CLOSE表中,就将它们放入OPEN表,并把S放入CLOSE表,同时计算每一个后继结点的估价值f(n),将OPEN表按f(x)排序,最小的放在表头,重复算法,回到1。
importjava.util.Stack;
PublicclassAXing{//A*搜索类
IntMaxWeight=M;
//表示无穷大
PublicvoidA_Search(Graphg,intH[],intv0,intend){/v/H:
启发式函数值
booleanflag=true;
//表示栈顶元素
intvex;
//寻找目标节点
IntMinF,MinVex=v0;
//记录最小的f(n)和对应的节点
int[][]GHF=newint[g.path.length][3];
//分别用于存储g(n),h(n),f(n)
g.path.length;
GHF[i][0]=0;
GHF[i][2]=MaxWeight;
//对f(n)初始化,1000表示无穷大
//v0入栈
GHF[v0][0]=0;
//g(n)
GHF[v0][1]=H[v0];
//h(n)
GHF[v0][2]=GHF[v0][0]+GHF[v0][1];
//f(n)
while(flag){
MinF=MaxWeight;
//处理第一个子节点
vex=g.getFirstVex(x);
if(vex==end){//找到目标节点
stack.push(vex);
g.mark[vex]=1;
if(vex!
=-1){//子节点能找到,继续
if(g.mark[vex]==0){//没被访问
GHF[vex][0]=GHF[x][0]+g.path[x][vex];
//节点vex的g(n)
GHF[vex][1]=H[vex];
//节点vex的h(n)
GHF[vex][2]=GHF[vex][0]+GHF[vex][1];
if(GHF[vex][2]<
MinF){
MinF=GHF[vex][2];
MinVex=vex;
//处理剩下的邻接点(宽度遍历)
while(vex!
=-1){
vex=g.getNextVex(x,vex);
=-1&
g.mark[vex]==0){//有邻节点
if(vex==-1){//没有邻接点了,此时确定最小消耗节点,并压栈
stack.push(MinVex);
g.mark[MinVex]=1;
if(vex==end){
stack.push(vex);
//压栈目标节点
g.mark[vex]=1;
flag=false;
else{//没有子节点或者子节点被访问了,循环出栈
while(vex==-1){
三、实验结果:
四、实验分析:
(1)深度优先搜索
根据结果可只知,在有限状态空间下,树搜索不是完备的,图搜索完备;
无限状态下不完备。
此结果0->
1->
2->
4->
6->
10->
11->
12只是其中一条,但不是最优解。
分支因子b,深度d。
则最坏情况下时间复杂度也高达,空间复杂度
,内存需求少。
(2)一致代价搜索
从结果0->
12可以看出。
是最优解,他的复杂度不能简单地使用b、d刻画。
得使用C*表示最优解的耗散值。
时间复杂度,空间复杂度。
(3)A*树搜索
A*搜索估价值h(n)<
=
n到目标节点的距离实际值,这种情况下,搜索的点数多,搜索范围大,效率低。
但能得到最优解。
并且如果h(n)=d(n),即距离估计h(n)等于最短距离,那么搜索将严格沿着最短路径进行,
此时的搜索效率是最高的。
如果
估价值>
实际值,搜索的点数少,搜索范围小,效率高,但不能保证得到最优解。
五、思考题
1、根据实验结果分析深度优先搜索,一致代价搜索,迭代加深的深度优先搜索算法的时间和空间复杂度。
2、根据实验结果分析A*搜索的性能。
答:
A*算法是一种静态路网中求解最短路径最有效的直接搜索方法。
估价值与实际值越接近,估价函数取得就越好。
0-》4-》6-》11-》12-14-》15从图中可以看出是最优解,估价值h(n)<
此时的搜索效率
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 人工智能 实验