人工智能化(A星算法)

合集下载

人工智能A星算法

人工智能A星算法
人工智能A星算法（A* Algorithm）是一种启发式算法，它能够解决从一个起始点到特定终点的最短路径问题。

该算法是利用基于启发式的算法和最优子结构性质，该算法在空间中生成了一条最佳路径，既可以简单而又可靠。

A*算法通过评估每条路径的风险和代价，来确定最佳路径。

对于一个节点，算法将图上的所有可能路径的代价总和折算成一个“分数”，把这些“分数”比较，选择最低分的路径为最优路径。

（1）定义一个空间，在这个空间中有起点到终点的路径，并且定义一些实体：路点、障碍物、起点、终点等；
（2）将起点放入开放列表，开始；
（3）从开放列表中取出一个节点（称作当前节点），检查是否为终点，如果是，结束，如果不是，将当前节点放入关闭列表；
（4）在开放列表中寻找临近节点，将临近节点放入开放列表，并对每一个节点计算从起点到该节点的代价F，该代价由起点到当前节点的距离G和该节点距离终点的估价H之和；
（5）重复以上步骤，直到从开放列表中取出的节点是终点；
（6）返回最佳路径。

a星算法求解八数码问题python

a星算法求解八数码问题python一、介绍八数码问题是一种经典的智力游戏，也是人工智能领域中的经典问题之一。

在这个问题中，有一个3×3的棋盘，上面摆着1至8这8个数字和一个空格，初始状态和目标状态都已知。

要求通过移动数字，将初始状态变换成目标状态。

其中空格可以和相邻的数字交换位置。

为了解决这个问题，我们可以使用A*算法。

本文将详细介绍如何用Python实现A*算法来求解八数码问题。

二、A*算法简介A*算法是一种启发式搜索算法，常用于寻找最短路径或最优解等问题。

它基于Dijkstra算法，并加入了启发式函数来加速搜索过程。

在A*算法中，每个节点都有两个估价值：g值和h值。

g值表示从起点到该节点的实际代价，h值表示从该节点到目标节点的估计代价。

启发式函数f(n) = g(n) + h(n) 表示从起点到目标节点的估计总代价。

A*算法采用优先队列来保存待扩展的节点，并按照f(n)值从小到大排序。

每次取出队头元素进行扩展，并将扩展出来的新节点按照f(n)值插入队列中。

当扩展出目标节点时，算法结束。

三、八数码问题的状态表示在八数码问题中，每个状态都可以表示为一个3×3的矩阵。

我们可以用一个一维数组来表示这个矩阵，其中0表示空格。

例如，初始状态可以表示为[2, 8, 3, 1, 6, 4, 7, 0, 5]，目标状态可以表示为[1, 2, 3, 8, 0, 4, 7, 6, 5]。

四、A*算法求解八数码问题的步骤1.将初始状态加入优先队列中，并设置g值和h值为0。

2.从队头取出一个节点进行扩展。

如果该节点是目标节点，则搜索结束；否则，将扩展出来的新节点加入优先队列中。

3.对于每个新节点，计算g值和h值，并更新f(n)值。

如果该节点已经在优先队列中，则更新其估价值；否则，将其加入优先队列中。

4.重复第2步至第3步直到搜索结束。

五、Python实现以下是用Python实现A*算法求解八数码问题的代码：```import heapqimport copy# 目标状态goal_state = [1,2,3,8,0,4,7,6,5]# 启发式函数：曼哈顿距离def h(state):distance = 0for i in range(9):if state[i] == 0:continuerow = i // 3col = i % 3goal_row = (state[i]-1) // 3goal_col = (state[i]-1) % 3distance += abs(row - goal_row) + abs(col - goal_col)return distance# A*算法def A_star(start_state):# 初始化优先队列和已访问集合queue = []visited = set()# 将初始状态加入优先队列中，并设置g值和h值为0heapq.heappush(queue, (h(start_state), start_state, 0))while queue:# 取出队头元素进行扩展f, state, g = heapq.heappop(queue)# 如果该节点是目标节点，则搜索结束；否则，将扩展出来的新节点加入优先队列中。

启发式搜索A星算法

启发式搜索——初识A*算法A*在游戏中有它很典型的用法，是人工智能在游戏中的代表。

A*算法在人工智能中是一种典型的启发式搜索算法，为了说清楚A*算法，先说说何谓启发式算法。

一、何谓启发式搜索算法在说它之前先提提状态空间搜索。

状态空间搜索，如果按专业点的说法，就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。

通俗点说，就是在解一个问题时，找到一个解题的过程，应用这个过程可以从求解的开始得到问题的结果。

由于求解问题的过程中分支有很多，主要是求解过程中求解条件的不确定性、不完备性造成的，使得求解的路径很多，这样就构成了一个图，我们说这个图就是状态空间。

问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。

这个寻找的过程就是状态空间搜索。

常用的状态空间搜索有深度优先和广度优先。

广度优先是从初始状态一层一层向下找，直到找到目标为止。

深度优先是按照一定的顺序，先查找完一个分支，再查找另一个分支，直至找到目标为止。

这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。

前面说的广度和深度优先搜索有一个很大的缺陷就是：他们都是在一个给定的状态空间中穷举。

这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不可预测的情况下就不可取了。

他们的效率实在太低，甚至不可完成。

在这里就要用到启发式搜索了。

启发式搜索就是在状态空间中搜索时，对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直至找到目标。

这样可以省略大量无谓的搜索路径，提高了效率。

在启发式搜索中，对位置的估价是十分重要的。

采用了不同的估价可以有不同的效果。

我们先看看估价是如何表示的。

启发中的估价是用估价函数表示的，如：f(n) = g(n) + h(n)其中f(n)是节点n的估价函数，g(n)是在状态空间中从初始节点到n节点的实际代价，h(n)是从n节点到目标节点最佳路径的估计代价。

在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。

A星算法详解

初识A*算法写这篇文章的初衷是应一个网友的要求，当然我也发现现在有关人工智能的中文站点实在太少，我在这里抛砖引玉，希望大家都来热心的参与。

还是说正题，我先拿A*算法开刀，是因为A*在游戏中有它很典型的用法，是人工智能在游戏中的代表。

A*算法在人工智能中是一种典型的启发式搜索算法，为了说清楚A*算法，我看还是先说说何谓启发式算法。

一、何谓启发式搜索算法在说它之前先提提状态空间搜索。

状态空间搜索，如果按专业点的说法就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。

通俗点说，就是在解一个问题时，找到一条解题的过程可以从求解的开始到问题的结果（好象并不通俗哦）。

由于求解问题的过程中分枝有很多，主要是求解过程中求解条件的不确定性，不完备性造成的，使得求解的路径很多这就构成了一个图，我们说这个图就是状态空间。

问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。

这个寻找的过程就是状态空间搜索。

常用的状态空间搜索有深度优先和广度优先。

广度优先是从初始状态一层一层向下找，直到找到目标为止。

深度优先是按照一定的顺序前查找完一个分支，再查找另一个分支，以至找到目标为止。

这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。

前面说的广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。

这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不预测的情况下就不可取了。

他的效率实在太低，甚至不可完成。

在这里就要用到启发式搜索了。

启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。

这样可以省略大量无畏的搜索路径，提到了效率。

在启发式搜索中，对位置的估价是十分重要的。

采用了不同的估价可以有不同的效果。

我们先看看估价是如何表示的。

启发中的估价是用估价函数表示的，如：f(n) = g(n) + h(n)其中f(n)是节点n的估价函数，g(n)实在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。

人工智能A星算法解决八数码难题程序代码

#include "Stdio.h"#include "Conio.h"#include "stdlib.h"#include "math.h"void Copy_node(struct node *p1,struct node *p2);void Calculate_f(int deepth,struct node *p);void Add_to_open(struct node *p);void Add_to_closed(struct node *p);void Remove_p(struct node *name,struct node *p);int Test_A_B(struct node *p1,struct node *p2);struct node * Search_A(struct node *name,struct node *temp);void Print_result(struct node *p);struct node // 定义8数码的节点状态{int s[3][3]; //当前8数码的状态int i_0; //当前空格所在行号int j_0; //当前空格所在列号int f; //当前代价值int d; //当前节点深度int h; //启发信息，采用数码"不在位"距离和struct node *father; //指向解路径上该节点的父节点struct node *next; //指向所在open或closed表中的下一个元素} ;struct node s_0={{2,8,3,1,6,4,7,0,5},2,1,0,0,0,NULL,NULL}; //定义初始状态struct node s_g={{1,2,3,8,0,4,7,6,5},1,1,0,0,0,NULL,NULL}; //定义目标状态struct node *open=NULL; //建立open表指针struct node *closed=NULL; //建立closed表指针int sum_node=0; //用于记录扩展节点总数//***********************************************************//********************** **********************//********************** 主函数开始**********************//********************** **********************//***********************************************************void main(){int bingo=0; //定义查找成功标志，bingo=1，成功struct node s; //定义头结点sstruct node *target,*n,*ls,*temp,*same; //定义结构体指针Copy_node(&s_0,&s); //复制初始状s_0态给头结点s Calculate_f(0,&s); //计算头结点的代价值Add_to_open(&s); //将头结点s放入open表while(open!=NULL) //只要open表不为空，进行以下循环{n=open; //n指向open表中当前要扩展的元素ls=open->next;Add_to_closed(n);open=ls; //将n指向的节点放入closed表中if(Test_A_B(n,&s_g)) //当前n指向节点为目标时，跳出程序结束；否则，继续下面的步骤{bingo=1;break;}elseif(n->j_0>=1) //空格所在列号不小于1,可左移{temp=n->father;if(temp!=NULL&&temp->i_0==n->i_0&&temp->j_0-1==n->j_0) //新节点与其祖父节点相同;else //新节点与其祖父节点不同，或其父节点为起始节点{temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间Copy_node(n,temp); //拷贝n指向的节点状态temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0][temp->j_0-1]; //空格左移temp->s[temp->i_0][temp->j_0-1]=0;temp->j_0--;temp->d++;Calculate_f(temp->d,temp); //修改新节点的代价值temp->father=n; //新节点指向其父节点if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比closed表中相同状态节点代价小，加入open表{Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else;}else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比open表中相同状态节点代价小，加入open表{Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else ;}else //新节点为完全不同的新节点，加入open表{Add_to_open(temp);sum_node++;}}}//end左移if(n->j_0<=1) //空格所在列号不大于1,可右移{temp=n->father;if(temp!=NULL&&temp->i_0==n->i_0&&temp->j_0+1==n->j_0) //新节点与其祖父节点相同;else //新节点与其祖父节点不同，或其父节点为起始节点{temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间Copy_node(n,temp); //拷贝p指向的节点状态temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0][temp->j_0+1]; //空格右移temp->s[temp->i_0][temp->j_0+1]=0;temp->j_0++;temp->d++;Calculate_f(temp->d,temp); //修改新节点的代价值temp->father=n; //新节点指向其父节点if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比closed表中相同状态节点代价小，加入open表{Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else;}else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比open表中相同状态节点代价小，加入open表{Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else ;}else //新节点为完全不同的新节点，加入open表{Add_to_open(temp);sum_node++;}}}//end右移if(n->i_0>=1) //空格所在列号不小于1,上移{temp=n->father;if(temp!=NULL&&temp->i_0==n->i_0-1&&temp->j_0==n->j_0) //新节点与其祖父节点相同;else //新节点与其祖父节点不同，或其父节点为起始节点{temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间Copy_node(n,temp); //拷贝p指向的节点状态temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0-1][temp->j_0]; //空格上移temp->s[temp->i_0-1][temp->j_0]=0;temp->i_0--;temp->d++;Calculate_f(temp->d,temp); //修改新节点的代价值temp->father=n; //新节点指向其父节点if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比closed表中相同状态节点代价小，加入open表{Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else;}else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比open表中相同状态节点代价小，加入open表{Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else ;}else //新节点为完全不同的新节点，加入open表{Add_to_open(temp);sum_node++;}}}//end上移if(n->i_0<=1) //空格所在列号不大于1,下移{temp=n->father;if(temp!=NULL&&temp->i_0==n->i_0+1&&temp->j_0==n->j_0) //新节点与其祖父节点相同;else //新节点与其祖父节点不同，或其父节点为起始节点{temp=(struct node *)malloc(sizeof(struct node)); //给新节点分配空间Copy_node(n,temp); //拷贝p指向的节点状态temp->s[temp->i_0][temp->j_0]=temp->s[temp->i_0+1][temp->j_0]; //空格下移temp->s[temp->i_0+1][temp->j_0]=0;temp->i_0++;temp->d++;Calculate_f(temp->d,temp); //修改新节点的代价值temp->father=n; //新节点指向其父节点if(same=Search_A(closed,temp)) //在closed表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比closed表中相同状态节点代价小，加入open表{Remove_p(closed,same); //从closed表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else;}else if(same=Search_A(open,temp)) //在open表中找到与新节点状态相同的节点{if(temp->f<same->f) //temp指向的节点,其代价比open表中相同状态节点代价小，加入open表{Remove_p(open,same); //从open表中删除与temp指向节点状态相同的节点Add_to_open(temp);sum_node++;}else ;}else //新节点为完全不同的新节点，加入open表{Add_to_open(temp);sum_node++;}}}//end下移}if(bingo=1) Print_result(n); //输出解路径else printf("问题求解失败！");}//主函数结束//*************************************************************************//********************** **********************//********************** 计算某个节点状态的代价值**********************//********************** **********************//*************************************************************************void Calculate_f(int deepth,struct node *p){int i,j,temp;temp=0;for(i=0;i<=2;i++) //计算所有"不在位"数码的距离和{for(j=0;j<=2;j++){if((p->s[i][j])!=(s_g.s[i][j]))temp++;}}p->h=temp;p->f=deepth+p->h;}//*************************************************************************//********************** **********************//********************** 添加p指向的节点到open表中**********************//********************** **********************//*************************************************************************void Add_to_open(struct node *p){struct node *p1,*p2;p1=open; //初始时p1指向open表首部p2=NULL;if(open==NULL) //open表为空时，待插入节点即为open表第一个元素，open指向该元素{p->next=NULL;open=p;}else //open表不为空时，添加待插入节点，并保证open表代价递增的排序{while(p1!=NULL&&p->f>p1->f){p2=p1; //p2始终指向p1指向的前一个元素p1=p1->next;}if(p2==NULL) //待插入节点为当前open表最小{p->next=open;open=p;}else if(p1==NULL) //待插入节点为当前open表最大{p->next=NULL;p2->next=p;}else //待插入节点介于p2、p1之间{p2->next=p;p->next=p1;}}}//***************************************************************************//********************** **********************//********************** 添加p指向的节点到closed表中********************** //********************** **********************//***************************************************************************void Add_to_closed(struct node *p){if(closed==NULL) //closed表为空时，p指向节点为closed表第一个元素，closed指向该元素{p->next=NULL;closed=p;}else //closed表不为空时，直接放到closed表首部{p->next=closed;closed=p;}}//***************************************************************************** *********************//********************************************//********************** 在open表或closed表中搜索和temp指向的节点相同的节点**********************//********************************************//***************************************************************************** *********************struct node * Search_A(struct node *name,struct node *temp){struct node *p1;p1=name; //p1指向open表或closed表while(p1!=NULL){if(Test_A_B(p1,temp)) //找到相同的节点，返回该节点地址return p1;elsep1=p1->next;}return NULL;}//***************************************************************************** ******************//********************************************//********************** 判断两个节点状态是否相同，相同则返回1，否则返回0 **********************//********************************************//***************************************************************************** ******************int Test_A_B(struct node *p1,struct node *p2){int i,j,flag;flag=1;for(i=0;i<=2;i++)for(j=0;j<=2;j++){if((p2->s[i][j])!=(p1->s[i][j])) { flag=0; return flag; }else ;}return flag;}//***************************************************************************** *//********************************************//********************** 从open表或closed表删除指定节点**********************//********************************************//***************************************************************************** *void Remove_p(struct node *name,struct node *p){struct node *p1,*p2;p1=NULL;p2=NULL;if(name==NULL) //如果name指向的链表为空，则不需要进行删除return;else if(Test_A_B(name,p)&&name->f==p->f) //指定节点为name指向的链表的第一个元素{open=name->next;name->next=NULL;return;}else{p2=name;p1=p2->next;while(p1){if(Test_A_B(p1,p)&&p1->f==p->f) //找到指定节点{p2->next=p1->next;return;}else{p2=p1; //p2始终指向p1指向的前一个元素p1=p1->next;}}return;}}//***************************************************************************** *********//********************************************//********************** 将p1指向的节点状态拷贝到p2指向的节点中**********************//********************************************//***************************************************************************** *********void Copy_node(struct node *p1,struct node *p2){int i,j;for(i=0;i<=2;i++){for(j=0;j<=2;j++){ p2->s[i][j]=p1->s[i][j]; }}p2->i_0=p1->i_0;p2->j_0=p1->j_0;p2->f=p1->f;p2->d=p1->d;p2->h=p1->h;p2->next=p1->next;p2->father=p1->father;}//***********************************************************//********************** **********************//********************** 输出结果**********************//********************** **********************//***********************************************************void Print_result(struct node *p){struct node *path[100];struct node *temp,*temp_father;int i,j,k;for(i=0;i<=99;i++) //初始化路径指针数组path[i]=0;temp=p;printf("总共扩展%d 个节点\n",sum_node);printf("总共扩展%d 层\n",temp->d);printf("解路径如下：\n");for(i=p->d;i>=0;i--) //存储解路径上各节点的地址{path[i]=temp;temp=temp->father;}for(k=0;k<=p->d;k++) //输出解路径{temp=path[k]; //建立节点指点指针printf("第%d步",temp->d);if(k-1>=0) //输出移动策略{temp_father=path[k-1];if(temp->i_0<temp_father->i_0) printf("->上移\n");if(temp->i_0>temp_father->i_0) printf("->下移\n");if(temp->j_0<temp_father->j_0) printf("->左移\n");if(temp->j_0>temp_father->j_0) printf("->右移\n");}elseprintf("\n");printf("当前节点状态为：\n");for(i=0;i<=2;i++){for(j=0;j<=2;j++){printf("%d ",temp->s[i][j]);}printf("\n");}printf("\n");}}。

启发式搜索A星算法

启发式搜索——初识A*算法A*在游戏中有它很典型的用法，是人工智能在游戏中的代表。

A*算法在人工智能中是一种典型的启发式搜索算法，为了说清楚A*算法，先说说何谓启发式算法。

一、何谓启发式搜索算法在说它之前先提提状态空间搜索。

状态空间搜索，如果按专业点的说法，就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。

通俗点说，就是在解一个问题时，找到一个解题的过程，应用这个过程可以从求解的开始得到问题的结果。

问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。

这个寻找的过程就是状态空间搜索。

常用的状态空间搜索有深度优先和广度优先。

广度优先是从初始状态一层一层向下找，直到找到目标为止。

深度优先是按照一定的顺序，先查找完一个分支，再查找另一个分支，直至找到目标为止。

这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。

前面说的广度和深度优先搜索有一个很大的缺陷就是：他们都是在一个给定的状态空间中穷举。

这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不可预测的情况下就不可取了。

他们的效率实在太低，甚至不可完成。

在这里就要用到启发式搜索了。

启发式搜索就是在状态空间中搜索时，对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直至找到目标。

这样可以省略大量无谓的搜索路径，提高了效率。

在启发式搜索中，对位置的估价是十分重要的。

采用了不同的估价可以有不同的效果。

我们先看看估价是如何表示的。

在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。

a星算法原理

a星算法原理1. 基本思路A* 算法是基于图模型的搜索算法，其中图由若干个节点和连接这些节点的边组成。

搜索的目标是在图上寻找一条从起点到终点的最优路径。

A* 算法的基本思路如下：（1）首先将起点加入open列表（即待搜索的节点列表），定义一个空的close列表（即已搜索的节点列表）。

（2）从open列表中取出F值最小的节点，将其加入close列表。

（3）若该节点为终点，则搜索完成，否则将它的相邻节点加入open列表。

（4）对于所有加入open列表的节点，计算它们的F值，并更新它们的父节点。

（5）重复步骤2-4，直到open列表为空或者找到终点。

F值由G值和H值组成：F =G + HG值表示从起点到该节点的实际代价，H值表示从该节点到终点的启发式估价（即一个估计值，不一定是实际值，但必须保证不小于实际值）。

1.启发式估价函数必须保证不小于实际代价。

2.启发式估价函数应该尽量接近实际代价，否则会影响搜索效率。

3.启发式估价函数不能产生死循环或者走回头路的情况。

2. 估价函数的选取（1）曼哈顿距离曼哈顿距离指两点之间横纵坐标差的绝对值之和。

曼哈顿距离是一种比较简单的启发式估价函数，它适用于只能沿水平或竖直方向移动的情况。

曼哈顿距离在斜着走的时候有一定的误差，不够精确。

（2）欧几里得距离欧几里得距离指两点之间的直线距离。

欧几里得距离是一种比较精确的启发式估价函数，它适用于可以在任何方向上移动的情况。

欧几里得距离会导致算法不够稳定，容易出现死循环的情况。

（3）切比雪夫距离（4）自定义估价函数如果以上的估价函数不能满足需要，还可以根据具体需求自定义估价函数。

自定义估价函数要满足启发式估价函数的基本要求，并且尽量简单易实现。

3. A*算法的优缺点（1）A*算法具有较高的搜索效率，并且能够找到最优解。

（2）A*算法能够通过启发式估价函数优化搜索路径，从而减少搜索量。

（1）A*算法的搜索效率和搜索结果非常依赖于所选择的估价函数，不同的估价函数可能产生完全不同的搜索结果。

a星算法资料

A星算法A星算法是一种常用的路径规划算法，它可以在很多领域得到应用，如游戏开发、机器人导航等。

本文将介绍A星算法的原理、实现过程以及应用场景。

原理A星算法是一种启发式搜索算法，用于寻找从起点到目标点的最佳路径。

它基于Dijkstra算法和最小堆叠加了启发式因子来加速搜索过程。

A星算法在搜索过程中维护两个集合：开放集合和关闭集合。

开放集合存储待探索的节点，而关闭集合存储已经探索过的节点。

算法的核心思想是维护每个节点的估价函数f值，其中f值由节点到目标点的实际代价g值和节点到目标点的启发函数h值组成。

在每一步中，算法从开放集合中选择f值最小的节点进行拓展，并更新其邻居节点的f值。

实现过程1.初始化起点，并将其加入开放集合中，设置启发函数h值为起点到目标点的估计代价。

2.重复以下步骤直到目标节点被加入关闭集合：–从开放集合中选择f值最小的节点，将其加入关闭集合。

–针对选定节点的每个邻居节点，计算其新的f值并更新。

–如果邻居节点不在开放集合中，将其加入开放集合。

3.构建路径，反向回溯从目标节点到起点的最佳路径。

应用场景•游戏开发：A星算法可以用来实现游戏中的AI寻路，使NPC角色能够智能地避开障碍物。

•机器人导航：A星算法可以帮助机器人避开障碍物，规划出最优的路径来到目标点。

•交通规划：A星算法可以用来优化城市道路的规划，减少交通拥堵，提高车辆通行效率。

•资源调度：A星算法可以帮助企业在多个资源之间寻找最佳路径，提高资源利用率。

总之，A星算法在许多领域都有着广泛的应用，它的高效性和可扩展性使其成为一种非常有力的路径规划工具。

结语A星算法是一种非常经典的路径规划算法，其优秀的性能和广泛的应用使其成为计算机科学领域的重要研究内容。

希望本文介绍的内容对读者有所帮助，让大家更加深入了解A星算法的原理和应用。

A星算法及其应用

A*算法及其应用（转载）2008-06-14 22:15一．引言图论是计算机科学中的一个重要研究工具，它产生于欧拉（Euler）对图的连通性的研究，但直到本世纪计算机诞生以后才得最迅猛的发展。

图论中的最短路径问题在计算机中有着广泛的应用，例如网络通信中最短路由的选择，人工智能中搜索算法的研究等。

本文对几种常见最短路径的算法进行介绍，尤其是在1968年发展起来的A*算法。

二．常用算法简介为叙述的方便，本文中假定所有图均以邻接矩阵表示，并将图论中的常用符号列于下：G---------------------无向图或有向图A=[aij]----------------图G的邻接矩阵表示V(G)------------------图G的顶点数ε(G)-----------------图G的边数。

1. Floyd算法这是几种最短路径算法中最简单的一种，本文不详细介绍，仅给出算法描述。

算法：For k:=1 to n doFor i:=1 to n doFor j:=1 to n doIf A[i,j]+A[k,j]<A[i,j] thenA[i,j]=a[i,k]+a[k,j];易知该算法的复杂度为o(n3)。

执行该算法后矩阵A中aij即为点i与点j间的最短路径，若要求路径的具体行程，需在算法中以数组保存路径的改变信息，这里不再介绍。

2. Dijkstra算法这种算法是Dijkstra于1959年提出的，主要用于计算图G中的某一点u0到其它点的最短距离。

算法：Step1:令l(u0)=0;l(v)=∞;v≠u0S0={u0};v=0;Step2:"vÎ┑Si=V(G)-Sil(v)=min{l(v),l(uI)+ω(ui,v)}设uI+1是使l(v)取到最小值的┑Si中的点。

令Si+1=Si∪{ui+1}Step3:If i=γ(G)-1 then Stop.If i<γ(G)-1 then i=i+1,Goto Step2.该算法的复杂度为o(n2)。

A星算法解决迷宫问题说明文档

A*算法解决迷宫问题算法思想：迷宫问题可以表述为：一个二维的网格，0表示点可走，1表示点不可以走，点用（x，y）表示，寻找从某一个给定的起始单元格出发，经由行相邻或列相邻的单元格(可以通过的)，最终可以到达目标单元格的、所走过的单元格序列。

在任一个单元格中，都只能看到与它邻近的4个单元格(如果位于底边，则只有3个；位于4个角上，则只有2个是否能通过)。

A*算法是人工智能中的一种搜索算法，是一种启发式搜索算法，它不需遍历所有节点，只是利用包含问题启发式信息的评价函数对节点进行排序，使搜索方向朝着最有可能找到目标并产生最优解的方向。

它的独特之处是检查最短路径中每个可能的节点时引入了全局信息，对当前节点距终点的距离做出估计，并作为评价节点处于最短路线上的可能性的度量。

A*算法中引入了评估函数，评估函数为：f（n）=g（n）+h（n）其中：n是搜索中遇到的任意状态。

g(n)是从起始状态到n的代价。

h(n)是对n到目标状态代价的启发式估计。

即评估函数f ( n) 是从初始节点到达节点n 处已经付出的代价与节点n 到达目标节点的接近程度估价值的总和。

这里我们定义n点到目标点的最小实际距离为h（n）*，A*算法要满足的条件为：h（n）<=h（n）*迷宫走的时候只能往上下左右走，每走一步，代价为1，这里我们采用的估价函数为当前节点到目标节点的曼哈顿距离，即：h（n）=|end.x –n.x|+ |end.y –n.y|这里end表示迷宫的目标点，n表示当前点，很明显这里h（n）<=h（n）*。

g（n）容易表示，即每走一步的代价是1，所以利用f（n）=g（n）+h（n）这种策略，我们可以不断地逼近目标点，从而找到问题的解。

时间复杂度：m行n列的迷宫矩阵实现算法的时间复杂度为O(m*n).结果演示：源码：#include <queue>#include <vector>#include <iostream>using namespace std;int direc[4][2]={{0,1},{-1,0},{0,-1},{1,0}};enum Flag{SEAL,OPEN,UNVISITED};typedef struct node{int _x,_y; //节点坐标(x,y)int _G; //实际已开销Gint _H; //探测将开销Hint _F; //优先级_F=_G+_H struct node *pre; //前驱顶点}Queue_Node;typedef struct{Flag flag;Queue_Node *point;}Seal;class A_Star{public://构造函数A_Star(){input();}~A_Star(){for(int i=1;i<=_len;++i){for(int j=1;j<=_wid;++j){if(_seal[i][j].point!=NULL){delete _seal[i][j].point;}}}for(i=0;i<=_len;++i){delete []_seal[i];delete []_maze[i];}delete []_seal;delete []_maze;}void input(){cout<<"输入: 迷宫左边长,上边宽! 例如：30 20"<<endl;cin>>_len>>_wid;_seal=new Seal*[_len+1];_maze=new unsigned char*[_len+1];for(int i=0;i<=_len;++i){_seal[i]=new Seal[_wid+1];_maze[i]=new unsigned char[_wid+1];}cout<<"从下一行开始输入迷宫信息："<<endl;for( i=1;i<=_len;++i){for(int j=1;j<=_wid;++j){cin>>_maze[i][j];_seal[i][j].flag=UNVISITED;_seal[i][j].point=NULL;}}cout<<"输入起点坐标,目标点坐标,例如:1 1 30 20"<<endl;cin>>_sx>>_sy>>_ex>>_ey;if(_maze[_sx][_sy]=='1'||_maze[_ex][_ey]=='1'||bound(_sx,_sy)==false||bound(_ex,_ey)==fal se){cout<<"不可能存在这样的情况！"<<endl;return;}cout<<"调用A*算法打印结果如下："<<endl;A();}//A*核心算法void A(){//源点放入开放列表Queue_Node *p_node=new Queue_Node;p_node->pre=NULL;p_node->_H=get_H(_sx,_sy);p_node->_G=0;p_node->_x=_sx;p_node->_y=_sy;p_node->_F=p_node->_H+p_node->_G;_open.push(p_node);_seal[_sx][_sy].flag=OPEN;_seal[_sx][_sy].point=p_node;while(!_open.empty()){p_node=_open.top();_open.pop();int x=p_node->_x;int y=p_node->_y;_seal[x][y].flag=SEAL;for(int i=0;i<4;++i){int tx=x+direc[i][0];int ty=y+direc[i][1];if(bound(tx,ty)==false||_maze[tx][ty]=='1'||_seal[tx][ty].flag==SEAL){continue;}if(_seal[tx][ty].flag==UNVISITED){if(tx==_ex&&ty==_ey){print(p_node);cout<<"("<<tx<<","<<ty<<")"<<endl;cout<<"总共走了:"<<p_node->_F<<"步"<<endl;return;}Queue_Node *temp=new Queue_Node;_seal[tx][ty].flag=OPEN;_seal[tx][ty].point=temp;temp->pre=p_node;temp->_G=p_node->_G+1;temp->_x=tx;temp->_y=ty;temp->_H=get_H(tx,ty);temp->_F=temp->_G+temp->_H;_open.push(temp);}else{Queue_Node *temp=_seal[tx][ty].point;if(p_node->_G+1<temp->_G){temp->_G=p_node->_G+1;temp->pre=p_node;temp->_F=temp->_G+temp->_H;}}}}cout<<"没有从("<<_sx<<","<<_sy<<")--->"<<"("<<_ex<<","<<_ey<<")的路径"<<endl;}//打印路径void print(Queue_Node *p){if(p==NULL){return;}print(p->pre);cout<<"("<<p->_x<<","<<p->_y<<"),";}bool bound(int x,int y){return (x<=_len)&&(x>=1)&&(y<=_wid)&&(y>=1);}int get_H(int x,int y){return ab(x-_ex)+ab(y-_ey);}int ab(int i){return i<0 ? -i:i;}private:struct cmp{bool operator()(Queue_Node *n1,Queue_Node *n2){return n1->_F>n2->_F;}};priority_queue<Queue_Node *,vector<Queue_Node *>,cmp> _open;//最小堆(开放列表) int _len,_wid;//迷宫左边长,上边宽int _sx,_sy,_ex,_ey;Seal **_seal;//动态开辟封闭列表unsigned char **_maze;//迷宫地图};int main(){A_Star test;return 0;}。

A星算法详解-精选.pdf

中 g(n)是节点所在的层数， h(n)=0，这种 h(n)肯定小于 h'(n) ，
所以由前述可知广度优先算法是一种可采纳的。实际也是。
当然它是一种最臭的 A* 算法。再说一个问题，就是有关 h(n)启发函数的信息性。 h(n)
的信息性通俗点说其实就是在估计一个节点的值时的约束
条件，如果信息越多或约束条件越多则排除的节点就越多，
A* 算法又是一种什么样的算法呢？其实
A* 算法也是一种最
好优先的算法。只不过要加上一些约束条件罢了。由于在一
些问题求解时，我们希望能够求解出状态空间搜索的最短路
径，也就是用最快的方法求解问题， A* 就是干这种事情的！我们先下个定义，如果一个估价函数可以找出最短的路径，
我们称之为可采纳性。 A* 算法是一个可采纳的最好优先算法。
Node->x = dx; Node->y = dy;
// make Open List point to first node
OPEN->NextNode=Node;
先看搜索主函数：
void AstarPathfinder::FindPath(int sx, int sy, int dx, int dy)
{
NODE *Node, *BestNode;
int TileNumDest;
// 得到目标位置，作判断用
TileNumDest = TileNum(sx, sy);
估价函数越好或说这个算法越好。这就是为什么广度优先算
法的那么臭的原因了，谁叫它的 h(n)=0，一点启发信息都没有。但在游戏开发中由于实时性的问题， h(n)的信息越多，
它的计算量就越大，耗费的时间就越多。就应该适当的减小

A星算法详解学习资料

A星算法详解学习资料A星算法详解初识A*算法写这篇⽂章的初衷是应⼀个⽹友的要求，当然我也发现现在有关⼈⼯智能的中⽂站点实在太少，我在这⾥抛砖引⽟，希望⼤家都来热⼼的参与。

还是说正题，我先拿A*算法开⼑，是因为A*在游戏中有它很典型的⽤法，是⼈⼯智能在游戏中的代表。

A*算法在⼈⼯智能中是⼀种典型的启发式搜索算法，为了说清楚A*算法，我看还是先说说何谓启发式算法。

⼀、何谓启发式搜索算法在说它之前先提提状态空间搜索。

状态空间搜索，如果按专业点的说法就是将问题求解过程表现为从初始状态到⽬标状态寻找这个路径的过程。

通俗点说，就是在解⼀个问题时，找到⼀条解题的过程可以从求解的开始到问题的结果（好象并不通俗哦）。

由于求解问题的过程中分枝有很多，主要是求解过程中求解条件的不确定性，不完备性造成的，使得求解的路径很多这就构成了⼀个图，我们说这个图就是状态空间。

问题的求解实际上就是在这个图中找到⼀条路径可以从开始到结果。

这个寻找的过程就是状态空间搜索。

常⽤的状态空间搜索有深度优先和⼴度优先。

⼴度优先是从初始状态⼀层⼀层向下找，直到找到⽬标为⽌。

深度优先是按照⼀定的顺序前查找完⼀个分⽀，再查找另⼀个分⽀，以⾄找到⽬标为⽌。

这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。

前⾯说的⼴度和深度优先搜索有⼀个很⼤的缺陷就是他们都是在⼀个给定的状态空间中穷举。

这在状态空间不⼤的情况下是很合适的算法，可是当状态空间⼗分⼤，且不预测的情况下就不可取了。

他的效率实在太低，甚⾄不可完成。

在这⾥就要⽤到启发式搜索了。

启发式搜索就是在状态空间中的搜索对每⼀个搜索的位置进⾏评估，得到最好的位置，再从这个位置进⾏搜索直到⽬标。

这样可以省略⼤量⽆畏的搜索路径，提到了效率。

在启发式搜索中，对位置的估价是⼗分重要的。

采⽤了不同的估价可以有不同的效果。

我们先看看估价是如何表⽰的。

启发中的估价是⽤估价函数表⽰的，如：f(n) = g(n) + h(n)其中f(n)是节点n的估价函数，g(n)实在状态空间中从初始节点到n节点的实际代价，h(n)是从n到⽬标节点最佳路径的估计代价。

A星算法详解

A星算法详解集团企业公司编码：（LL3698-KKI1269-TM2483-LUI12689-ITT289-初识A*算法写这篇文章的初衷是应一个网友的要求，当然我也发现现在有关人工智能的中文站点实在太少，我在这里抛砖引玉，希望大家都来热心的参与。

还是说正题，我先拿A*算法开刀，是因为A*在游戏中有它很典型的用法，是人工智能在游戏中的代表。

A*算法在人工智能中是一种典型的启发式搜索算法，为了说清楚A*算法，我看还是先说说何谓启发式算法。

一、何谓启发式搜索算法在说它之前先提提状态空间搜索。

状态空间搜索，如果按专业点的说法就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。

通俗点说，就是在解一个问题时，找到一条解题的过程可以从求解的开始到问题的结果（好象并不通俗哦）。

问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。

这个寻找的过程就是状态空间搜索。

常用的状态空间搜索有深度优先和广度优先。

广度优先是从初始状态一层一层向下找，直到找到目标为止。

深度优先是按照一定的顺序前查找完一个分支，再查找另一个分支，以至找到目标为止。

这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。

前面说的广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。

这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不预测的情况下就不可取了。

他的效率实在太低，甚至不可完成。

在这里就要用到启发式搜索了。

启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。

这样可以省略大量无畏的搜索路径，提到了效率。

在启发式搜索中，对位置的估价是十分重要的。

采用了不同的估价可以有不同的效果。

我们先看看估价是如何表示的。

人工智能(A星算法)

(A星算法)本文档介绍了中的A星算法的详细内容。

A星算法是一种常用的搜索算法，用于求解图中路径问题。

本文将从算法原理、具体步骤以及优化方案等方面进行详细介绍。

1.算法原理A星算法是一种启发式搜索算法，通过估算每个节点到目标节点的代价来确定搜索的方向。

具体而言，A星算法使用了两个评估函数：g(x)表示从起始节点到当前节点的实际代价，h(x)表示从当前节点到目标节点的预估代价。

通过综合考虑这两个代价，选择最优路径进行搜索。

2.算法步骤2.1 初始化首先，创建一个空的开放列表用于存储待搜索的节点，以及一个空的关闭列表用于存储已搜索过的节点。

将起始节点添加到开放列表中。

2.2 循环搜索2.2.1 选择最优节点从开放列表中选择具有最小f(x) = g(x) + h(x)值的节点作为当前节点。

2.2.2 扩展相邻节点对当前节点的相邻节点进行扩展，计算它们的g(x)和h(x)值，并更新它们的父节点和f(x)值。

2.2.3 判断终止条件如果目标节点属于开放列表中的节点，则搜索结束。

如果开放列表为空，表示无法找到路径，搜索也结束。

2.2.4 更新列表将当前节点从开放列表中移除，并添加到关闭列表中，表示已经搜索过。

2.3 构建路径从目标节点开始，通过追踪每个节点的父节点，直到回溯到起始节点，构建出最优路径。

3.算法优化3.1 启发函数的选择选择合适的启发函数可以极大地影响算法的效率和搜索结果。

常用的启发函数有曼哈顿距离、欧几里得距离等。

根据具体问题的特点，选择合适的启发函数进行优化。

3.2 剪枝策略在节点扩展过程中，通过对相邻节点的估价值进行快速筛选，可以减少搜索的时间和空间开销。

根据具体问题的特点，设计合理的剪枝策略，减少无效节点的扩展。

4.附件本文档没有涉及附件内容。

5.法律名词及注释A星算法：是一种常用的搜索算法，用于求解图中路径问题。

目前该算法已经广泛应用于领域。

6.结束标识。

A星算法的简单原理

A星算法的简单原理A星算法（A* algorithm）是一种常用于路径规划的算法，它能够在图形中找到最短路径。

本文将详细介绍A星算法的原理及其实现过程。

一、A星算法的原理A星算法是一种启发式算法，它通过估计离目标节点最短距离来为每个节点评分，从而决定下一步应该扩展的节点。

A星算法通常用于二维图形中，其中每个节点都有一定的代价或权重。

1. 创建一个开放列表（open list）和一个关闭列表（closedlist）。

-开放列表用于保存可能成为最佳路径的节点。

-关闭列表用于保存已经扩展过的节点。

2.将起始节点添加到开放列表中，并设置其启发式评分（也称为f值）为0。

3.重复以下步骤，直到找到目标节点或者开放列表为空。

a.从开放列表中选择一个节点，称之为当前节点。

选择当前节点的依据是当前节点的f值最低。

b.将当前节点移到关闭列表中。

c.对当前节点的邻居节点进行遍历。

d.对于每个邻居节点，判断它是否在关闭列表中，如果是则忽略。

其父节点为当前节点。

同时计算邻居节点的f值、g值和h值。

-g值是起始节点到当前节点的实际代价。

-h值是当前节点到目标节点的估计代价，也称为启发式评估。

-f值是g值和h值的和，用于排序开放列表中的节点。

4.当找到目标节点时，可以通过遍历每个节点的父节点，从而最终得到最短路径。

5.如果开放列表为空，表示找不到目标节点，路径规划失败。

二、A星算法的实现1.定义节点类：节点类包含节点的坐标、父节点、g值和h值等属性。

2.创建开放列表和关闭列表：开放列表用于保存可能成为最佳路径的节点，关闭列表用于保存已经扩展过的节点。

3.初始化起始节点和目标节点，并将起始节点添加到开放列表中。

4.重复以下步骤，直到找到目标节点或者开放列表为空。

a.从开放列表中选择一个节点，称之为当前节点。

选择当前节点的依据是当前节点的f值最低。

b.将当前节点移到关闭列表中。

c.对当前节点的邻居节点进行遍历，计算邻居节点的f值、g值和h 值。

实验二 A星算法实验

人工智能基础（第2版）
实验二A*算法实验
1.提交期限和方法
2.实验目的
熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解N 数码难题，理解求解流程和搜索顺序。

3.实验任务
1）实现类似于如图所示N数码难题演示程序。

2）用你所熟悉的程序语言实现，可以B/S实现，也可以C/S实现。

4、实验内容
1）分别以8数码和15数码为例实际求解A*算法。

2）画出A*算法求解框图。

3）分析估价函数对搜索算法的影响。

4 ）分析A*算法的特点。

5、提交要求
1、本次实验为个人任务，需独立完成，以纸质和电子档的形式把实验报告提交给学习委员，再由学习委员在规定期限内提交给任课老师。

2、要求把所做的程序的演示图附加到实验报告上，代码不需要添加到实验报告上。

3、撰写实验报告
实验报告具体内容如下：
实验题目、实验目的、实验原理、实验条件、实验内容、实验步骤、程序代码、个人实验小结。

4、未按时提交实验报告者，每迟交一天扣1分，扣完为止。

经辅导员同意并签字的事病假时间不计入迟交范围。

凡被发现实验报告有抄袭者，本次成绩以零分记。

A星算法

还是说正题，我先拿A*算法开刀，是因为A*在游戏中有它很典型的用法，是人工智能在游戏中的代表。

A*算法在人工智能中是一种典型的启发式搜索算法，为了说清楚A*算法，我看还是先说说何谓启发式算法。

一、何谓启发式搜索算法在说它之前先提提状态空间搜索。

状态空间搜索，如果按专业点的说法就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。

通俗点说，就是在解一个问题时，找到一条解题的过程可以从求解的开始到问题的结果（好象并不通俗哦）。

问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。

这个寻找的过程就是状态空间搜索。

常用的状态空间搜索有深度优先和广度优先。

广度优先是从初始状态一层一层向下找，直到找到目标为止。

深度优先是按照一定的顺序前查找完一个分支，再查找另一个分支，以至找到目标为止。

这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。

前面说的广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。

这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不预测的情况下就不可取了。

他的效率实在太低，甚至不可完成。

在这里就要用到启发式搜索了。

启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。

这样可以省略大量无畏的搜索路径，提到了效率。

在启发式搜索中，对位置的估价是十分重要的。

采用了不同的估价可以有不同的效果。

我们先看看估价是如何表示的。

A星算法详解-通俗易懂初学者必看

t(智乐圆入门1)A*(A星)算法(一)记得好象刚知道游戏开发这一行的时候老师就提到过A星算法,当时自己基础还不行,也就没有去看这方面的资料,前几天找了一些资料,研究了一天,觉的现在网上介绍A星算法的资料都讲的不够详细(因为我下的那个资料基本算是最详细的了- -但是都有一些很重要的部分没有说清楚....),所以我自己重新写一篇讲解A星算法的资料,还是借用其他资料的一些资源.不过转载太多了,只有谢谢原作者了:)我们将以下图作为地图来进行讲解,图中对每一个方格都进行了编号,其中绿色的方格代表起点,红色的方格代表终点,蓝色的方格代表障碍,我们将用A星算法来寻找一条从起点到终点最优路径,为了方便讲解,本地图规定只能走上下左右4个方向,当你理解了A星算法,8个方向也自然明白在地图中,每一个方格最基本也要具有两个属性值,一个是方格是通畅的还是障碍,另一个就是指向他父亲方格的指针(相当于双向链表结构中的父结点指针),我们假设方格值为0时为通畅,值为1时为障碍A星算法中,有2个相当重要的元素,第一个就是指向父亲结点的指针,第二个就是一个OPEN表,第三个就是CLOSE表,这两张表的具体作用我们在后面边用边介绍,第四个就是每个结点的F值(F值相当于图结构中的权值)而F = H + G;其中H值为从网格上当前方格移动到终点的预估移动耗费。

这经常被称为启发式的，可能会让你有点迷惑。

这样叫的原因是因为它只是个猜测。

我们没办法事先知道路径的长度，因为路上可能存在各种障碍(墙，水，等等)。

虽然本文只提供了一种计算H的方法，但是你可以在网上找到很多其他的方法,我们定义H 值为终点所在行减去当前格所在行的绝对值与终点所在列减去当前格所在列的绝对值之和,而G值为从当前格的父亲格移动到当前格的预估移动耗费,在这里我们设定一个基数10,每个H和G都要乘以10,这样方便观察好了,我们开始对地图进行搜索首先,我们将起点的父亲结点设置为NULL,然后将起点的G值设置为0,再装进open 表里面,然后将起点作为父亲结点的周围4个点20,28,30,38(因为我们地图只能走4个方向,如果是8方向,则要加个点进去)都加进open列表里面,并算去每个结点的H 值,然后再将起点从open列表删除,放进close表中,我们将放进close表的所有方格都用浅蓝色线条进行框边处理,所以这次搜索以后,图片变为如下格式,其中箭头代表的是其父结点其中每个格子的左下方为G值,右下方为H值,左上方为H值,我们拿28号格子为例来讲解一写F值的算法,首先因为终点33在4行7列,而28在4行2列,则行数相差为0,列数相差为5,总和为5,再乘以我们先前定的基数10,所以H值为50,又因为从28的父结点29移动到28,长度为1格,而29号为起点，G值为0,所以在父亲结点29的基础上移动到28所消耗的G值为(0 + 1) *10 = 10,0为父亲结点的G值,1为从29到28的消耗当前OPEN表中的值: 20,28,30,38 当前CLOSE表中的值: 29现在我们开始寻找OPEN列表中F值最低的,得出结点30的F值最低,且为40,然后将结点30从OPEN表中删除,然后再加入到CLOSE表中,然后在判断结点30周围4个结点,因为结点31为障碍,结点29存在于CLOSE表中,我们将不处理这两点,只将21和39号结点加入OPEN表中,添加完后地图变为下图样式当前OPEN表中的值: 20,28,38,21,39 当前CLOSE表中的值: 29,30接着我们重复上面的过程,寻找OPEN表中F值为低的值,我们发现OPEN表中所有结点的F值都为60,我们随即取一个结点,这里我们直接取最后添加进OPEN表中的结点,这样方便访问(因为存在这样的情况,所有从一个点到另外一个点的最短路径可能不只一条),我们取结点39,将他从OPEN表中删除,并添加进CLOSE表中,然后观察39号结点周围的4个结点,因为40号结点为障碍,所以我们不管它,而30号结点已经存在与OPEN表中了,所以我们要比较下假设39号结点为30号结点的父结点,30号结点的G值会不会更小,如果更小的话我们将30结点的父结点改为39号,这里我们以39号结点为父结点,得出30号结点的新G值为20,而30号结点原来的G值为10,并不比原来的小,所以我们不对30号进行任何操作,同样的对38号结点进行上述操作后我们也不对它进行任何操作,接着我们把48号结点添加进OPEN表中,添加完后地图变为下图样式当前OPEN表中的值: 20,28,38,21,48 当前CLOSE表中的值: 29,30,39以后的过程中我们都重复这样的过程,一直到遍历到了最后终点,通过遍历父结点编号,我们能够得出一条最短路径,具体完整的推导过程我就不写出来了,因为和刚才那几步是一样的，这里我再讲出一个特例,然后基本A星算法就没问题了上面的最后一推导中,我们在观察39号结点时,发现他周围已经有结点在OPEN表中了,我说"比较下假设39号结点为30号结点的父结点,30号结点的G值会不会更小,如果更小的话我们将30结点的父结点改为39号",但是刚才没有遇到G值更小的情况，所以这里我假设出一种G值更小的情况,然后让大家知道该怎么操作,假设以39号为父结点,我们得出的30号的新G值为5(只是假设),比30号的原G值10还要小,所以我们要修改路径,改变30号的箭头,本来他是指向29号结点的，我们现在让他指向39号结点,38号结点的操作也一样好了,A星算法的大体思路就是这样了，对于8方向的地图来说，唯一的改变就是G 值方面,在上下左右,我们的G值是加10,但是在斜方向我们要加14,其他的和上面讲的一样~~~:)PS: 今天下午去天门网络面试,我竟然连简历都没带- -空着个手带了个人就去了....都不晓得我当时杂想的...汗(智乐圆入门2)终于把A*寻路算法看懂了，虽然还有点小问题，但A*寻路算法我已经略知一二，帮助还不知道的朋友进入A*算法入门阶级，应该不成问题，下面就来看看A*算法的原理（以下讲解不带入任何程序语言，因此只要你看懂了下面所有的话，那么你可以随意用在任意程序语言中）在下也是初学，写这篇文章的目的只是让新手入门，因此高手看到这就飘过吧，当然愿意给予指点的高手请继续往下看前言：在文中可能会出现一些专业术语或者是我信口雌黄的话语，未免看官不明白，前面我先加以注解，具体意思可以从文中体会到方格：一个一个的小方块障碍物：挡着去路的东西目标方格：你想到达的方格操控方格：你控制的寻路对象标记：临时为某一个方格做的标记父标记：除了操控方格所创建的临时标记，每个标记都有个父标记，但父标记不是随便乱定的，请看下文开启标记列表：当该标记还未进行过遍历，会先加入到开启标记列表中关闭标记列表：当该标记已经进行过遍历，会加入到关闭标记列表中路径评分：通过某种算法，计算当前所遍历的标记离目标方格的路径耗费估值（后面会讲一种通用的耗费算法）首先描述一个环境，在一望无际的方格中，我身处某某方格，如今我想去某某方格，接下来我开始寻路！在脑海中，先创建开启标记列表、关闭标记列表，然后把我的初始位置设置为开始标记进行遍历，同时因为开始标记已经遍历过了，因此把开始标记加入到关闭列表。