The Fourth Dimension Space

枯叶北风寒,忽然年以残,念往昔,语默心酸。二十光阴无一物,韶光贱,寐难安; 不畏形影单,道途阻且慢,哪曲折,如渡飞湍。斩浪劈波酬壮志,同把酒,共言欢! -如梦令

A*算法详解——by Sunway

写这篇文章的初衷是应一个网友的要求,当然我也发现现在有关人工智能的中文站点实在太少,我在这里抛砖引玉,希望大家都来热心的参与。还是说正题,我先拿A*算法开刀,是因为A*在游戏中有它很典型的用法,是人工智能在游戏中的代表。A*算法在人工智能中是一种典型的启发式搜索算法,为了说清楚A*算法,我看还是先说说何谓启发式算法。

1、何谓启发式搜索算法
  在说它之前先提提状态空间搜索。状态空间搜索,如果按专业点的说法就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。通俗点说,就是在解一个问题时,找到一条解题的过程可以从求解的开始到问题的结果(好象并不通俗哦)。由于求解问题的过程中分枝有很多,主要是求解过程中求解条件的不确定性,不完备性造成的,使得求解的路径很多这就构成了一个图,我们说这个图就是状态空间。问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。这个寻找的过程就是状态空间搜索。
  常用的状态空间搜索有深度优先和广度优先。广度优先是从初始状态一层一层向下找,直到找到目标为止。深度优先是按照一定的顺序前查找完一个分支,再查找另一个分支,以至找到目标为止。这两种算法在数据结构书中都有描述,可以参看这些书得到更详细的解释。
  前面说的广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。这在状态空间不大的情况下是很合适的算法,可是当状态空间十分大,且不预测的情况下就不可取了。他的效率实在太低,甚至不可完成。在这里就要用到启发式搜索了。
  启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估,得到最好的位置,再从这个位置进行搜索直到目标。这样可以省略大量无畏的搜索路径,提到了效率。在启发式搜索中,对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。我们先看看估价是如何表示的。
  启发中的估价是用估价函数表示的,如:

f(n) = g(n) + h(n)

  其中f(n) 是节点n的估价函数,g(n)实在状态空间中从初始节点到n节点的实际代价,h(n)是从n到目标节点最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息,因为g(n)是已知的。如果说详细点,g(n)代表了搜索的广度的优先趋势。但是当h(n) >> g(n)时,可以省略g(n),而提高效率。这些就深了,不懂也不影响啦!我们继续看看何谓A*算法。

2、初识A*算法
  启发式搜索其实有很多的算法,比如:局部择优搜索法、最好优先搜索法等等。当然A*也是。这些算法都使用了启发函数,但在具体的选取最佳搜索节点时的策略不同。象局部择优搜索法,就是在搜索的过程中选取“最佳节点”后舍弃其他的兄弟节点,父亲节点,而一直得搜索下去。这种搜索的结果很明显,由于舍弃了其他的节点,可能也把最好的节点都舍弃了,因为求解的最佳节点只是在该阶段的最佳并不一定是全局的最佳。最好优先就聪明多了,他在搜索时,便没有舍弃节点(除非该节点是死节点),在每一步的估价中都把当前的节点和以前的节点的估价值比较得到一个“最佳的节点”。这样可以有效的防止“最佳节点”的丢失。那么A*算法又是一种什么样的算法呢?其实A*算法也是一种最好优先的算法。只不过要加上一些约束条件罢了。由于在一些问题求解时,我们希望能够求解出状态空间搜索的最短路径,也就是用最快的方法求解问题,A*就是干这种事情的!我们先下个定义,如果一个估价函数可以找出最短的路径,我们称之为可采纳性。A*算法是一个可采纳的最好优先算法。A*算法的估价函数可表示为:

f'(n) = g'(n) + h'(n)

  这里,f'(n)是估价函数,g'(n)是起点到终点的最短路径值,h'(n)是n到目标的最断路经的启发值。由于这个f'(n)其实是无法预先知道的,所以我们用前面的估价函数f(n)做近似。g(n)代替g'(n),但 g(n)>=g'(n)才可(大多数情况下都是满足的,可以不用考虑),h(n)代替h'(n),但h(n)<=h'(n)才可(这一点特别的重要)。可以证明应用这样的估价函数是可以找到最短路径的,也就是可采纳的。我们说应用这种估价函数的最好优先算法就是A*算法。哈。你懂了吗?肯定没懂。接着看。
  举一个例子,其实广度优先算法就是A*算法的特例。其中g(n)是节点所在的层数,h(n)=0,这种h(n)肯定小于h'(n),所以由前述可知广度优先算法是一种可采纳的。实际也是。当然它是一种最臭的A*算法。
再说一个问题,就是有关h(n)启发函数的信息性。h(n)的信息性通俗点说其实就是在估计一个节点的值时的约束条件,如果信息越多或约束条件越多则排除的节点就越多,估价函数越好或说这个算法越好。这就是为什么广度优先算法的那么臭的原因了,谁叫它的h(n)=0,一点启发信息都没有。但在游戏开发中由于实时性的问题,h(n)的信息越多,它的计算量就越大,耗费的时间就越多。就应该适当的减小h(n)的信息,即减小约束条件。但算法的准确性就差了,这里就有一个平衡的问题。可难了,这就看你的了!
  好了我的话也说得差不多了,我想你肯定是一头的雾水了,其实这是写给懂A*算法的同志看的。哈哈。你还是找一本人工智能的书仔细看看吧!我这几百字是不足以将A*算法讲清楚的。只是起到抛砖引玉的作用希望大家热情参与吗。




在这里我将对A*算法的实际应用进行一定的探讨,并且举一个有关A*算法在最短路径搜索的例子。值得注意的是这里并不对A*的基本的概念作介绍,如果你还对A*算法不清楚的话,请看姊妹篇《初识A*算法》。
  这里所举的例子是参考AMIT主页中的一个源程序,你可以在AMIT的站点上下载也可以在我的站点上下载。你使用这个源程序时,应该遵守一定的公约。

1、A*算法的程序编写原理
  我在《初识A*算法》中说过,A*算法是最好优先算法的一种。只是有一些约束条件而已。我们先来看看最好优先算法是如何编写的吧。如图有如下的状态空间:(起始位置是A,目标位置是P,字母后的数字表示节点的估价值)。
  如图有如下的状态空间:(起始位置是A,目标位置是P,字母后的数字表示节点的估价值)

图1 状态空间图

  搜索过程中设置两个表:OPEN和CLOSED。OPEN表保存了所有已生成而未考察的节点,CLOSED表中记录已访问过的节点。算法中有一步是根据估价函数重排OPEN表。这样循环中的每一步只考虑OPEN表中状态最好的节点。具体搜索过程如下:

  1)初始状态:
      OPEN=[A5];            CLOSED=[];
  2)估算A5,取得搜有子节点,并放入OPEN表中;
      OPEN=[B4, C4, D6];        CLOSED=[A5]
  3)估算B4,取得搜有子节点,并放入OPEN表中;
      OPEN=[C4, E5, F5, D6];      CLOSED=[B4, A5]
  4)估算C4;取得搜有子节点,并放入OPEN表中;
      OPEN=[H3, G4, E5, F5, D6]     CLOSED=[C4, B4, A5]
  5)估算H3,取得搜有子节点,并放入OPEN表中;
      OPEN=[O2, P3, G4, E5, F5, D6];  CLOSED=H3C4, B4, A5]
  6)估算O2,取得搜有子节点,并放入OPEN表中;
      OPEN=[P3, G4, E5, F5, D6];    CLOSED=[O2, H3, C4, B4, A5]
  7)估算P3,已得到解;

  看了具体的过程,再看看伪程序吧。算法的伪程序如下:

  Best_First_Search()
  {
    Open = [起始节点];
    Closed = [];
    while ( Open表非空 )
    {
      从Open中取得一个节点X, 并从OPEN表中删除.
      if (X是目标节点)
      {
        求得路径PATH;
        返回路径PATH;
      }
      for (每一个X的子节点Y)
      {
        if( Y不在OPEN表和CLOSE表中 )
        {
          求Y的估价值;
          并将Y插入OPEN表中; 
//还没有排序
        }
        else if( Y在OPEN表中 )
        {
          if( Y的估价值小于OPEN表的估价值 )
            更新OPEN表中的估价值;
        }
        else
//Y在CLOSE表中
        {
          if( Y的估价值小于CLOSE表的估价值 )
          {
            更新CLOSE表中的估价值;
            从CLOSE表中移出节点, 并放入OPEN表中;
          }
        }
        将X节点插入CLOSE表中;
        按照估价值将OPEN表中的节点排序;
      }
 //end for
    } //end while
  } //end func

  啊!伪程序出来了,写一个源程序应该不是问题了,依葫芦画瓢就可以。A*算法的程序与此是一样的,只要注意估价函数中的g(n)的h(n)约束条件就可以了。不清楚的可以看看《初识A*算法》。好了,我们可以进入另一个重要的话题,用A*算法实现最短路径的搜索。在此之前你最好认真的理解前面的算法。不清楚可以找我。

2、用A*算法实现最短路径的搜索
  在游戏设计中,经常要涉及到最短路径的搜索,现在一个比较好的方法就是用A*算法进行设计。他的好处我们就不用管了,反正就是好!
  注意下面所说的都是以ClassAstar这个程序为蓝本,你可以在这里下载这个程序。这个程序是一个完整的工程。里面带了一个EXE文件。可以先看看。
  先复习一下,A*算法的核心是估价函数f(n),它包括g(n)和h(n)两部分。g(n)是已经走过的代价,h(n)是n到目标的估计代价。在这个例子中g(n)表示在状态空间从起始节点到n节点的 深度,h(n)表示n节点所在地图的位置到目标位置的直线距离。啊!一个是状态空间,一个是实际的地图,不要搞错了。再详细点说,有一个物体A,在地图上的坐标是(xa,ya),A所要到达的目标b的坐标是(xb,yb)。则开始搜索时,设置一个起始节点1,生成八个子节点2 - 9 因为有八个方向。如图:

图2 节点图

  先看搜索主函数:

  
void AstarPathfinder::FindPath(int sx, int sy, int dx, int dy)
  
{
    NODE 
*Node, *BestNode;
    
int TileNumDest;

    
//得到目标位置,作判断用
    TileNumDest = TileNum(sx, sy);

    
//生成Open和Closed表
    OPEN=( NODE* )calloc(1,sizeof( NODE ));
    CLOSED
=( NODE* )calloc(1,sizeof( NODE ));

    
//生成起始节点,并放入Open表中
    Node=( NODE* )calloc(1,sizeof( NODE ));
    Node
->= 0;

    
//这是计算h值
    Node->= (dx-sx)*(dx-sx) + (dy-sy)*(dy-sy); // should really use sqrt().

    
//这是计算f值,即估价值
    Node->= Node->g+Node->h;
    Node
->NodeNum = TileNum(dx, dy);
    Node
->= dx;
    Node
->= dy;

    OPEN
->NextNode=Node; // make Open List point to first node
    for (;;)
    
{
      
//从Open表中取得一个估价值最好的节点
      BestNode=ReturnBestNode();

      
//如果该节点是目标节点就退出
      if (BestNode->NodeNum == TileNumDest) // if we've found the end, break and finish
        break;
      
//否则生成子节点
      GenerateSuccessors(BestNode,sx,sy);
    }

    PATH 
= BestNode;
  }


  再看看生成子节点函数 GenerateSuccessors:

  
void AstarPathfinder::GenerateSuccessors(NODE *BestNode, int dx, int dy)
  
{
    
int x, y;

    
//依次生成八个方向的子节点,简单!
    
// Upper-Left
    if ( FreeTile(x=BestNode->x-TILESIZE, y=BestNode->y-TILESIZE) )
      GenerateSucc(BestNode,x,y,dx,dy);
    
// Upper
    if ( FreeTile(x=BestNode->x, y=BestNode->y-TILESIZE) )
      GenerateSucc(BestNode,x,y,dx,dy);
    
// Upper-Right
    if ( FreeTile(x=BestNode->x+TILESIZE, y=BestNode->y-TILESIZE) )
      GenerateSucc(BestNode,x,y,dx,dy);
    
// Right
    if ( FreeTile(x=BestNode->x+TILESIZE, y=BestNode->y) )
      GenerateSucc(BestNode,x,y,dx,dy);
    
// Lower-Right
    if ( FreeTile(x=BestNode->x+TILESIZE, y=BestNode->y+TILESIZE) )
      GenerateSucc(BestNode,x,y,dx,dy);
    
// Lower
    if ( FreeTile(x=BestNode->x, y=BestNode->y+TILESIZE) )
      GenerateSucc(BestNode,x,y,dx,dy);
    
// Lower-Left
    if ( FreeTile(x=BestNode->x-TILESIZE, y=BestNode->y+TILESIZE) )
      GenerateSucc(BestNode,x,y,dx,dy);
    
// Left
    if ( FreeTile(x=BestNode->x-TILESIZE, y=BestNode->y) )
      GenerateSucc(BestNode,x,y,dx,dy);
  }


  看看最重要的函数GenerateSucc:

  
void AstarPathfinder::GenerateSucc(NODE *BestNode,int x, int y, int dx, int dy)
  
{
    
int g, TileNumS, c = 0;
    NODE 
*Old, *Successor;

    
//计算子节点的 g 值
    g = BestNode->g+1// g(Successor)=g(BestNode)+cost of getting from BestNode to Successor
    TileNumS = TileNum(x,y); // identification purposes

    
//子节点再Open表中吗?
    if ( (Old=CheckOPEN(TileNumS)) != NULL ) // if equal to NULL then not in OPEN list,
                         
// else it returns the Node in Old
    {
      
//若在
      for( c = 0; c <8; c++)
        
if( BestNode->Child[c] == NULL ) // Add Old to the list of BestNode's Children
                         
// (or Successors).
         break;
        BestNode
->Child[c] = Old;
        
//比较Open表中的估价值和当前的估价值(只要比较g值就可以了)
        if ( g g ) // if our new g value is Parent = BestNode;
          Old->= g;
          Old
->= g + Old->h;
        }

      }

      
else //在Closed表中吗?
        if ( (Old=CheckCLOSED(TileNumS)) != NULL ) // if equal to NULL then not in OPEN list
                              
// else it returns the Node in Old
        {
          
//若在
          for( c = 0; c<8; c++)
            
if ( BestNode->Child[c] == NULL ) // Add Old to the list of BestNode's
                             
// Children (or Successors). break;
            BestNode->Child[c] = Old;
            
//比较Closed表中的估价值和当前的估价值(只要比较g值就可以了)
            if ( g g ) // if our new g value is Parent = BestNode;
              Old->= g;
              Old
->= g + Old->h; //再依次更新Old的所有子节点的估价值
              PropagateDown(Old); // Since we changed the g value of Old, we need
                         
// to propagate this new value downwards, i.e.
                         
// do a Depth-First traversal of the tree!
             }

        }
        
else //不在Open表中也不在Close表中
        {
          
//生成新的节点
          Successor = ( NODE* )calloc(1,sizeof( NODE ));
          Successor
->Parent = BestNode;
          Successor
->= g;
          Successor
->= (x-dx)*(x-dx) + (y-dy)*(y-dy); // should do sqrt(), but since we
                                   don't really
          Successor->= g+Successor->h; // care about the distance but just which branch
          looks Successor->= x; // better this should suffice. Anyayz it's faster.
          Successor->= y;
          Successor
->NodeNum = TileNumS;
          
//再插入Open表中,同时排序。
          Insert(Successor); // Insert Successor on OPEN list wrt f
          for( c =0; c <8; c++)
            
if ( BestNode->Child[c] == NULL ) // Add Old to the list of BestNode's
                              Children (or Successors).
            
break;
          BestNode
->Child[c] = Successor;
        }

  }

  哈哈。A*算法我懂了。当然,我希望你有这样的感觉。不过我还要再说几句。仔细看看这个程序,你会发现,这个程序和我前面说的伪程序有一些不同,在GenerateSucc函数中,当子节点在Closed表中时,没有将子节点从Closed表中删除并放入Open表中。而是直接的重新的计算该节点的所有子节点的估价值(用PropagateDown函数)。这样可以快一些。另当子节点在Open表和Closed表中时,重新的计算估价值后,没有重新的对Open表中的节点排序,我有些想不通,为什么不排呢?会不会是一个小小的BUG。你知道告诉我好吗?
  好了。主要的内容都讲完了,还是完整仔细的看看源程序吧。希望我所的对你有一点帮助,一点点也可以。如果你对文章中的观点有异议或有更好的解释都告诉我。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
                                                                                                                                                ——by Drew
                                                                                 对sunway程序中的BUG所进行的修改


需要注意的是Sunway上面文章“深入A*算法”中引用了一个A*的游戏程序进行讲解,并有这个源码的下载,不过它有一个不小的Bug, 就是新的子节点放入OPEN表中进行了排序,而当子节点在Open表和Closed表中时,重新计算估价值后,没有重新的对Open表中的节点排序,这个问题会导致计算有时得不到最优解,另外在路网权重悬殊很大时,搜索范围不但超过Dijkstra,甚至搜索全部路网, 使效率大大降低。 

Drew 对这个问题进行了如下修正,当子节点在Open表和Closed表中时,重新计算估价值后,删除OPEN表中的老的节点,将有新估价值的节点插入OPEN表中,重新排序,经测试效果良好,修改的代码如下,红色部分为Drew添加的代码.添加进程序的相应部分即可。

在函数GenerateSucc()中 
...................................

g=BestNode->g+1/* g(Successor)=g(BestNode)+cost of getting from BestNode to Successor */
TileNumS
=TileNum((int)x,(int)y); /* identification purposes */
if ((Old=CheckOPEN(TileNumS)) != NULL) 

for(c=0;c<8;c++)
if(BestNode->Child[c] == NULL) /* Add Old to the list of BestNode's Children (or Successors). */
break;
BestNode
->Child[c]=Old;

if (g < Old->g) 
{
Old
->Parent=BestNode;
Old
->g=g;
Old
->f=g+Old->h; 

 
//Drew 在该处添加如下红色代码 
//Implement by Drew 
NODE *q,*p=OPEN->NextNode, *temp=OPEN->NextNode;
while(p!=NULL && p->NodeNum != Old->NodeNum)
{
    q
=p;
    p
=p->NextNode;
}

if(p->NodeNum == Old->NodeNum)
{
   
if(p==OPEN->NextNode)
  
{
     temp 
= temp->NextNode;
     OPEN 
->NextNode = temp;
  }

  
else
  q
->NextNode = p->NextNode;
 }

Insert(Old); 
// Insert Successor on OPEN list wrt f 
}
 

...................................................... 


posted on 2009-03-01 21:34 abilitytao 阅读(6072) 评论(9)  编辑 收藏 引用

评论

# re: A*算法详解——by Sunway 2009-03-02 22:25 Santhtony

good
tks  回复  更多评论   

# re: A*算法详解——by Sunway 2009-03-10 16:33 挑灯看剑

兄弟,能否给出原文的链接呢,转帖专业一些吧,3x!  回复  更多评论   

# re: A*算法详解——by Sunway[未登录] 2009-03-10 16:58 abilitytao

@挑灯看剑
网上转载的很多 我也是从某个网站上转来的 由于不是原作者的链接 故不给出 如果你想找原链接的话 我只能告诉你我没有啊 你可以自行搜索:-)  回复  更多评论   

# re: A*算法详解——by Sunway 2009-04-30 02:34 bneliao


粗略看一下,A*算法的本质是通过估价函数的贪婪(极值)行为在深度搜索和广度搜索做一个折中。游戏地图可以使用的原因在于估价函数反映的是起始点到要搜索的点及要搜索的点和目标点的三个点的两端距离。。  回复  更多评论   

# re: A*算法详解——by Sunway 2009-09-06 18:02 Ocean

传说用它来解八数码问题时,如果写得好...比双向宽搜还快了....  回复  更多评论   

# re: A*算法详解——by Sunway[未登录] 2010-07-12 13:35 abilitytao

@Ocean
是的 我用它来实现八数码 确实比双向广搜还快  回复  更多评论   

# re: A*算法详解——by Sunway[未登录] 2011-03-04 11:02 APRIL

图1 状态空间图 和图2 节点图 无法显示啊  回复  更多评论   

# re: A*算法详解——by Sunway 2011-03-08 17:14 Vincent

@bneliao
f'(n) = g'(n) + h'(n)
h'(n)=0,且g'(n')=g'(n)+1,n'是n的后继,为广搜
h'(n)=0,且g'(n')=g'(n)-1,n'是n的后继,为深搜
h'(n)=0,q'(n)为实际从起点至n点的路径,分枝定界法  回复  更多评论   

# re: A*算法详解——by Sunway 2011-07-31 19:18 FG

多NPC寻路后发现碰撞问题怎么解决  回复  更多评论   


只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理