A*算法求解最短路径

关于A*算法求解最短路径的问题介绍, 给出了一个搜索最短路径的程序。

近来不少的朋友问我关于 A* 算法的问题, 目的是写一个搜索最短路径的程序. 这个在鼠标控制精灵运动的游戏中(不算智冠出的那些用鼠标充当键盘方向键的弱智 RPG) 大量使用,尤其是即时战略类的. 但是我个人认为 A* 算法只适合处理静态路径求解, 对即时战略游戏中大量对象堵塞过道时,疏通交通很难实现(也不是不能实现, 这需要一个相当好的估价函数,且不能一次搜索路径) 

我奇怪的是, A* 算法应该是算法课的基础知识了, 任何一个系统学习过算法的人都应该了解, 本不应该我在这里乱写一通, 大家随意翻本将计算机算法的书, 就应该看的到. (讲 AI 的书了更是少不了) 不过既然许多朋友问起, 在各个讨论组, BBS 等地方也屡次见人提到, 特花一下午时间完成本文和附带的程序, 满足我们广大业余游戏制作爱好者的求知欲, 专业人士免看, 以免班门弄斧 ^_^ 不过如有错误一定指出哟. 

 

在介绍 A* 算法前,先提一下广度优先搜索,广度优先搜索就是每次将当前状态可能发展的策略逐层展开,比如一个地图中,对象允许向四个方向移动, 那么,就将地点处,对象向上下左右各移动一步, 将四个状态都保存在内存中, 然后再从这四个出发点向各自的四个方向再移动一步... (当然这里可以剔除不合理的移动方法,比如不准向回移动) 实际上, 整个搜索好似一个圆形向外展开,直到到达目的地,很明显这样求解一定能找到最优解,但节点展开的数量是和距离成级数增加的, 真的用在游戏中, 玩家会抱怨内存 128M 也不够用了 ^_^ 而且伴随待处理节点数的增加, 处理速度也会迅速减慢... 可以说这个算法并不实用 

 

而 A* 算法实际是一种启发式搜索, 所谓启发式搜索,就是利用一个估价函数评估每次的的决策的价值, 决定先尝试哪一种方案. 这样可以极大的优化普通的广度优先搜索. 一般来说, 从出发点(A)到目的地(B)的最短距离是固定的,我们可以写一个函数 judge() 估计 A 到 B 的最短距离, 如果程序已经尝试着从出发点(A) 沿着某条路线移动到了 C 点, 那么我们认为这个方案的 A B 间的估计距离为 A 到 C 实际已经行走了的距离 H 加上用 judge() 估计出的 C 到 B 的距离. 如此, 无论我们的程序搜索展开到哪一步, 都会算出一个评估值, 每一次决策后, 将评估值和等待处理的方案一起排序, 然后挑出待处理的各个方案中最有可能是最短路线的一部分的方案展开到下一步, 一直循环到对象移动到目的地, 或所有方案都尝试过却没有找到一条通向目的地的路径则结束. (通常在游戏里还要设置超时控制的代码,当内存消耗过大或用时过久就退出搜索) 

 

完了? 没有.
怎么写这个算法中的估价函数非常的重要,如何保证一定能找到最短路径呢? 充要条件是, 你的估价函数算出的两点间的距离必须小于等于实际距离. 这个可以从数学上严格证明,有兴趣可以自己去查阅相关资料. 如果你的估价函数不满足这点, 就只能叫做 A 算法, 并不能保证最后的结果是最优的,但它可能速度非常的快. 而游戏中我们也不一定非要得到最优解的. 但无疑, 满足那个条件的 A* 算法中, 估计值越接近真实值的估价函数就做的越好, 下面给出的程序,我只使用了一个相当简单的估价函数: 求出两点中,若无障碍物的情况下的最短路径. 如果您想写出快速的寻路算法, 请自己寻找好的估价函数吧,有时间的时候,我会对此另文叙述 ;-) 

 

下面附的程序我已经花时间注释过了, 并且调试通过.如果你经过思索后还是有不懂的地方, 可以来 E-mail 到 cloudwu@263.net ;-) 

 

 

 
 
/* 云风的求解最短路径代码 (Cloud Wu's Pathfinding code)
 
*                          1999 年 1月 8 日 (1999, Jan 8)
 
* 这段代码没有进行任何优化(包括算法上的), 但不意味我不知道该怎样优化它，
 
* 它是为教学目的而做,旨在用易于理解和简洁的代码描述出 A* 算法在求最段路
 
* 径中的运用. 由于很久没有摸算法书, 本程序不能保证是纯正的 A* 算法 ;-)
 
* 你可以在理解了这段程序的基础上,按自己的理解写出类似的代码. 但是简单的
 
* 复制它到你的程序中是不允许的,如果你真要这样干,请在直接使用它的软件的
 
* 文档中,写上我的名字 ;-)
 
* 有任何的问题,或建议请 E-mail 到 cloudwu@263.net 
 
* 欢迎参观我的主页 http://member.netease.com/~cloudwu (云风工作室)
 
* (你可以在上面找到一些有关这个问题的讨论,和有关游戏设计的其它大量资料)
 
*
 
* 本程序附带有一个数据文件 map.dat, 保存有地图的数据
 
*/
 

 
// #define NDEBUG
 

#include <stdio.h>
 

#include <conio.h>
 

#include <assert.h>
 

#include <stdlib.h>
 

#define MAPMAXSIZE 100  //地图面积最大为 100x100
 

#define MAXINT 8192     //定义一个最大整数, 地图上任意两点距离不会超过它
 

#define STACKSIZE 65536 //保存搜索节点的堆栈大小
 

 
#define tile_num(x,y) ((y)*map_w+(x))  //将 x,y 坐标转换为地图上块的编号
 

#define tile_x(n) ((n)%map_w)          //由块编号得出 x,y 坐标
 

#define tile_y(n) ((n)/map_w)
 

 
// 树结构, 比较特殊, 是从叶节点向根节点反向链接
 

typedef
 
struct
 node *TREE; 

 
struct
 node { 

    int
 h; 

    int
 tile; 

    TREE father; 
} ; 
 
typedef
 
struct
 node2 *LINK; 

 
struct
 node2 { 

    TREE node; 
    int
 f; 

    LINK next; 
}; 
 
LINK queue;               // 保存没有处理的行走方法的节点
 

TREE stack[STACKSIZE];    // 保存已经处理过的节点 (搜索完后释放)
 

int
 stacktop; 

unsigned char
 map[MAPMAXSIZE][MAPMAXSIZE];   
//地图数据
 

int
 dis_map[MAPMAXSIZE][MAPMAXSIZE];         
//保存搜索路径时,中间目标地最优解
 

 
int
 map_w,map_h;                             
//地图宽和高
 

int
 start_x,start_y,end_x,end_y;             
//地点,终点坐标
 

 
// 初始化队列
 

void
 init_queue() 

{ 
    queue=(LINK)malloc(sizeof
(*queue)); 

    queue->node=NULL; 
    queue->f=-1; 
    queue->next=(LINK)malloc(sizeof
(*queue)); 

    queue->next->f=MAXINT; 
    queue->next->node=NULL; 
    queue->next->next=NULL; 
} 
 
// 待处理节点入队列, 依靠对目的地估价距离插入排序
 

void
 enter_queue(TREE node,
int
 f) 

{ 
    LINK p=queue,father,q; 
    while
(f>p->f) { 

        father=p; 
        p=p->next; 
        assert(p); 
    } 
    q=(LINK)malloc(sizeof
(*q)); 

    assert(queue); 
    q->f=f,q->node=node,q->next=p; 
    father->next=q; 
} 
 
// 将离目的地估计最近的方案出队列
 

TREE get_from_queue() 
{ 
    TREE bestchoice=queue->next->node; 
    LINK next=queue->next->next; 
    free(queue->next); 
    queue->next=next; 
    stack[stacktop++]=bestchoice; 
    assert(stacktop<STACKSIZE); 
    return
 bestchoice; 

} 
 
// 释放栈顶节点
 

void
 pop_stack() 

{ 
    free(stack[--stacktop]); 
} 
 
// 释放申请过的所有节点
 

void
 freetree() 

{ 
    int
 i; 

    LINK p; 
    for
 (i=0;i<stacktop;i++) 

        free(stack[i]); 
    while
 (queue) { 

        p=queue; 
        free(p->node); 
        queue=queue->next; 
        free(p); 
    } 
} 
 
// 估价函数,估价 x,y 到目的地的距离,估计值必须保证比实际值小
 

int
 judge(
int
 x,
int
 y) 

{ 
    int
 distance; 

    distance=abs(end_x-x)+abs(end_y-y); 
    return
 distance; 

} 
 
// 尝试下一步移动到 x,y 可行否
 

int
 trytile(
int
 x,
int
 y,TREE father) 

{ 
    TREE p=father; 
    int
 h; 

    if
 (map[y][x]!=
' '
) 
return
 1; 
// 如果 (x,y) 处是障碍,失败
 

    while
 (p) { 

        if
 (x==tile_x(p->tile) && y==tile_y(p->tile)) 
return
 1; 
//如果 (x,y) 曾经经过,失败
 

        p=p->father; 
    } 
    h=father->h+1; 
    if
 (h>=dis_map[y][x]) 
return
 1; 
// 如果曾经有更好的方案移动到 (x,y) 失败
 

    dis_map[y][x]=h; // 记录这次到 (x,y) 的距离为历史最佳距离
 

     
    // 将这步方案记入待处理队列
 

    p=(TREE)malloc(sizeof
(*p)); 

    p->father=father; 
    p->h=father->h+1; 
    p->tile=tile_num(x,y); 
    enter_queue(p,p->h+judge(x,y)); 
    return
 0; 

} 
 
// 路径寻找主函数
 

void
 findpath(
int
 *path) 

{ 
    TREE root; 
    int
 i,j; 

    stacktop=0; 
    for
 (i=0;i<map_h;i++) 

        for
 (j=0;j<map_w;j++) 

            dis_map[i][j]=MAXINT; 
        init_queue(); 
        root=(TREE)malloc(sizeof
(*root)); 

        root->tile=tile_num(start_x,start_y); 
        root->h=0; 
        root->father=NULL; 
        enter_queue(root,judge(start_x,start_y)); 
        for
 (;;) { 

            int
 x,y,child; 

            TREE p; 
            root=get_from_queue(); 
            if
 (root==NULL) { 

                *path=-1; 
                return
; 

            } 
            x=tile_x(root->tile); 
            y=tile_y(root->tile); 
            if
 (x==end_x && y==end_y) 
break
; 
// 达到目的地成功返回
 

             
            child=trytile(x,y-1,root);  //尝试向上移动
 

            child&=trytile(x,y+1,root); //尝试向下移动
 

            child&=trytile(x-1,y,root); //尝试向左移动
 

            child&=trytile(x+1,y,root); //尝试向右移动
 

            if
 (child!=0) 

                pop_stack();  // 如果四个方向均不能移动,释放这个死节点
 

        } 
         
        // 回溯树，将求出的最佳路径保存在 path[] 中
 

        for
 (i=0;root;i++) { 

            path[i]=root->tile; 
            root=root->father; 
        } 
        path[i]=-1; 
        freetree(); 
} 
 
void
 printpath(
int
 *path) 

{ 
    int
 i; 

    for
 (i=0;path[i]>=0;i++) { 

        gotoxy(tile_x(path[i])+1,tile_y(path[i])+1); 
        cprintf("/xfe"
); 

    } 
} 
 
int
 readmap() 

{ 
    FILE
 *f; 

    int
 i,j; 

    f=fopen("map.dat"
,
"r"
); 

    assert(f); 
    fscanf(f,"%d,%d/n"
,&map_w,&map_h); 

    for
 (i=0;i<map_h;i++) 

        fgets(&map[i][0],map_w+1,f); 
    fclose(f); 
    start_x=-1,end_x=-1; 
    for
 (i=0;i<map_h;i++) 

        for
 (j=0;j<map_w;j++) { 

            if
 (map[i][j]==
's'
) map[i][j]=
' '
,start_x=j,start_y=i; 

            if
 (map[i][j]==
'e'
) map[i][j]=
' '
,end_x=j,end_y=i; 

        } 
        assert(start_x>=0 && end_x>=0); 
        return
 0; 

} 
 
void
 showmap() 

{ 
    int
 i,j; 

    clrscr(); 
    for
 (i=0;i<map_h;i++) { 

        gotoxy(1,i+1); 
        for
 (j=0;j<map_w;j++) 

            if
 (map[i][j]!=
' '
) cprintf(
"/xdb"
); 

            else
 cprintf(
" "
); 

    } 
    gotoxy(start_x+1,start_y+1); 
    cprintf("s"
); 

    gotoxy(end_x+1,end_y+1); 
    cprintf("e"
); 

} 
 
int
 main() 

{ 
    int
 path[MAXINT]; 

    readmap(); 
    showmap(); 
    getch(); 
    findpath(path); 
    printpath(path); 
    getch(); 
    return
 0; 

}