程序博客网 > 最好吃的方便面 知乎

A*算法

来源：互联网 发布：最好吃的方便面 知乎 编辑：程序博客网 时间：2024/05/22 12:12

在介绍 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 ;-) 
 
 
  1. /* 云风的求解最短路径代码 (Cloud Wu's Pathfinding code) 
  2. *                          1999 年 1月 8 日 (1999, Jan 8) 
  3. * 这段代码没有进行任何优化(包括算法上的), 但不意味我不知道该怎样优化它， 
  4. * 它是为教学目的而做,旨在用易于理解和简洁的代码描述出 A* 算法在求最段路 
  5. * 径中的运用. 由于很久没有摸算法书, 本程序不能保证是纯正的 A* 算法 ;-) 
  6. * 你可以在理解了这段程序的基础上,按自己的理解写出类似的代码. 但是简单的 
  7. * 复制它到你的程序中是不允许的,如果你真要这样干,请在直接使用它的软件的 
  8. * 文档中,写上我的名字 ;-) 
  9. * 有任何的问题,或建议请 E-mail 到 cloudwu@263.net  
  10. * 欢迎参观我的主页 http://member.netease.com/~cloudwu (云风工作室) 
  11. * (你可以在上面找到一些有关这个问题的讨论,和有关游戏设计的其它大量资料) 
  12. * 
  13. * 本程序附带有一个数据文件 map.dat, 保存有地图的数据 
  14. */ 
  15.  
  16. // #define NDEBUG 
  17. #include <stdio.h> 
  18. #include <conio.h> 
  19. #include <assert.h> 
  20. #include <stdlib.h> 
  21. #define MAPMAXSIZE 100  //地图面积最大为 100x100 
  22. #define MAXINT 8192     //定义一个最大整数, 地图上任意两点距离不会超过它 
  23. #define STACKSIZE 65536 //保存搜索节点的堆栈大小 
  24.  
  25. #define tile_num(x,y) ((y)*map_w+(x))  //将 x,y 坐标转换为地图上块的编号 
  26. #define tile_x(n) ((n)%map_w)          //由块编号得出 x,y 坐标 
  27. #define tile_y(n) ((n)/map_w) 
  28.  
  29. // 树结构, 比较特殊, 是从叶节点向根节点反向链接 
  30. typedef struct node *TREE; 
  31.  
  32. struct node { 
  33.     int h; 
  34.     int tile; 
  35.     TREE father; 
  36. } ; 
  37.  
  38. typedef struct node2 *LINK; 
  39.  
  40. struct node2 { 
  41.     TREE node; 
  42.     int f; 
  43.     LINK next; 
  44. }; 
  45.  
  46. LINK queue;               // 保存没有处理的行走方法的节点 
  47. TREE stack[STACKSIZE];    // 保存已经处理过的节点 (搜索完后释放) 
  48. int stacktop; 
  49. unsigned char map[MAPMAXSIZE][MAPMAXSIZE];   //地图数据 
  50. int dis_map[MAPMAXSIZE][MAPMAXSIZE];         //保存搜索路径时,中间目标地最优解 
  51.  
  52. int map_w,map_h;                             //地图宽和高 
  53. int start_x,start_y,end_x,end_y;             //地点,终点坐标 
  54.  
  55. // 初始化队列 
  56. void init_queue() 
  57. { 
  58.     queue=(LINK)malloc(sizeof(*queue)); 
  59.     queue->node=NULL; 
  60.     queue->f=-1; 
  61.     queue->next=(LINK)malloc(sizeof(*queue)); 
  62.     queue->next->f=MAXINT; 
  63.     queue->next->node=NULL; 
  64.     queue->next->next=NULL; 
  65. } 
  66.  
  67. // 待处理节点入队列, 依靠对目的地估价距离插入排序 
  68. void enter_queue(TREE node,int f) 
  69. { 
  70.     LINK p=queue,father,q; 
  71.     while(f>p->f) { 
  72.         father=p; 
  73.         p=p->next; 
  74.         assert(p); 
  75.     } 
  76.     q=(LINK)malloc(sizeof(*q)); 
  77.     assert(queue); 
  78.     q->f=f,q->node=node,q->next=p; 
  79.     father->next=q; 
  80. } 
  81.  
  82. // 将离目的地估计最近的方案出队列 
  83. TREE get_from_queue() 
  84. { 
  85.     TREE bestchoice=queue->next->node; 
  86.     LINK next=queue->next->next; 
  87.     free(queue->next); 
  88.     queue->next=next; 
  89.     stack[stacktop++]=bestchoice; 
  90.     assert(stacktop<STACKSIZE); 
  91.     return bestchoice; 
  92. } 
  93.  
  94. // 释放栈顶节点 
  95. void pop_stack() 
  96. { 
  97.     free(stack[--stacktop]); 
  98. } 
  99.  
  100. // 释放申请过的所有节点 
  101. void freetree() 
  102. { 
  103.     int i; 
  104.     LINK p; 
  105.     for (i=0;i<stacktop;i++) 
  106.         free(stack[i]); 
  107.     while (queue) { 
  108.         p=queue; 
  109.         free(p->node); 
  110.         queue=queue->next; 
  111.         free(p); 
  112.     } 
  113. } 
  114.  
  115. // 估价函数,估价 x,y 到目的地的距离,估计值必须保证比实际值小 
  116. int judge(int x,int y) 
  117. { 
  118.     int distance; 
  119.     distance=abs(end_x-x)+abs(end_y-y); 
  120.     return distance; 
  121. } 
  122.  
  123. // 尝试下一步移动到 x,y 可行否 
  124. int trytile(int x,int y,TREE father) 
  125. { 
  126.     TREE p=father; 
  127.     int h; 
  128.     if (map[y][x]!=' ') return 1; // 如果 (x,y) 处是障碍,失败 
  129.     while (p) { 
  130.         if (x==tile_x(p->tile) && y==tile_y(p->tile)) return 1; //如果 (x,y) 曾经经过,失败 
  131.         p=p->father; 
  132.     } 
  133.     h=father->h+1; 
  134.     if (h>=dis_map[y][x]) return 1; // 如果曾经有更好的方案移动到 (x,y) 失败 
  135.     dis_map[y][x]=h; // 记录这次到 (x,y) 的距离为历史最佳距离 
  136.      
  137.     // 将这步方案记入待处理队列 
  138.     p=(TREE)malloc(sizeof(*p)); 
  139.     p->father=father; 
  140.     p->h=father->h+1; 
  141.     p->tile=tile_num(x,y); 
  142.     enter_queue(p,p->h+judge(x,y)); 
  143.     return 0; 
  144. } 
  145.  
  146. // 路径寻找主函数 
  147. void findpath(int *path) 
  148. { 
  149.     TREE root; 
  150.     int i,j; 
  151.     stacktop=0; 
  152.     for (i=0;i<map_h;i++) 
  153.         for (j=0;j<map_w;j++) 
  154.             dis_map[i][j]=MAXINT; 
  155.         init_queue(); 
  156.         root=(TREE)malloc(sizeof(*root)); 
  157.         root->tile=tile_num(start_x,start_y); 
  158.         root->h=0; 
  159.         root->father=NULL; 
  160.         enter_queue(root,judge(start_x,start_y)); 
  161.         for (;;) { 
  162.             int x,y,child; 
  163.             TREE p; 
  164.             root=get_from_queue(); 
  165.             if (root==NULL) { 
  166.                 *path=-1; 
  167.                 return; 
  168.             } 
  169.             x=tile_x(root->tile); 
  170.             y=tile_y(root->tile); 
  171.             if (x==end_x && y==end_y) break; // 达到目的地成功返回 
  172.              
  173.             child=trytile(x,y-1,root);  //尝试向上移动 
  174.             child&=trytile(x,y+1,root); //尝试向下移动 
  175.             child&=trytile(x-1,y,root); //尝试向左移动 
  176.             child&=trytile(x+1,y,root); //尝试向右移动 
  177.             if (child!=0) 
  178.                 pop_stack();  // 如果四个方向均不能移动,释放这个死节点 
  179.         } 
  180.          
  181.         // 回溯树，将求出的最佳路径保存在 path[] 中 
  182.         for (i=0;root;i++) { 
  183.             path[i]=root->tile; 
  184.             root=root->father; 
  185.         } 
  186.         path[i]=-1; 
  187.         freetree(); 
  188. } 
  189.  
  190. void printpath(int *path) 
  191. { 
  192.     int i; 
  193.     for (i=0;path[i]>=0;i++) { 
  194.         gotoxy(tile_x(path[i])+1,tile_y(path[i])+1); 
  195.         cprintf("\xfe"); 
  196.     } 
  197. } 
  198.  
  199. int readmap() 
  200. { 
  201.     FILE *f; 
  202.     int i,j; 
  203.     f=fopen("map.dat","r"); 
  204.     assert(f); 
  205.     fscanf(f,"%d,%d\n",&map_w,&map_h); 
  206.     for (i=0;i<map_h;i++) 
  207.         fgets(&map[i][0],map_w+1,f); 
  208.     fclose(f); 
  209.     start_x=-1,end_x=-1; 
  210.     for (i=0;i<map_h;i++) 
  211.         for (j=0;j<map_w;j++) { 
  212.             if (map[i][j]=='s') map[i][j]=' ',start_x=j,start_y=i; 
  213.             if (map[i][j]=='e') map[i][j]=' ',end_x=j,end_y=i; 
  214.         } 
  215.         assert(start_x>=0 && end_x>=0); 
  216.         return 0; 
  217. } 
  218.  
  219. void showmap() 
  220. { 
  221.     int i,j; 
  222.     clrscr(); 
  223.     for (i=0;i<map_h;i++) { 
  224.         gotoxy(1,i+1); 
  225.         for (j=0;j<map_w;j++) 
  226.             if (map[i][j]!=' ') cprintf("\xdb"); 
  227.             else cprintf(" "); 
  228.     } 
  229.     gotoxy(start_x+1,start_y+1); 
  230.     cprintf("s"); 
  231.     gotoxy(end_x+1,end_y+1); 
  232.     cprintf("e"); 
  233. } 
  234.  
  235. int main() 
  236. { 
  237.     int path[MAXINT]; 
  238.     readmap(); 
  239.     showmap(); 
  240.     getch(); 
  241.     findpath(path); 
  242.     printpath(path); 
  243.     getch(); 
  244.     return 0; 
  245. } 
最好吃的方便面 知乎 最好吃的方便面 知乎
原创粉丝点击
热门IT博客
淘宝手机海报尺寸大小淘宝手机海报尺寸大小
图像去雾算法图像去雾算法
java抽象方法
知错改错善莫大焉
以下不属于数据库系统
聚宽量化交易平台 知乎
龙永图外孙女知乎
mac u盘启动盘制作
javascript基础题目
java socket经常断开
淘宝网跳蚤街
it occured that
英文写作软件
最有效的淘宝推广方式
麒麟950和骁龙660知乎
金融系统 网络拓扑
ubuntu查看jdk路径
mac无法无法解压文件
linux返回上一级目录
java bit
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 去散步的英语 散步对减肥有用吗 晨练 一个孤独者的散步 边打电话骗老公说在散步 电解质散喝完拉15次还是黄水 散水 散水做法 散水图片 复方苦参水杨酸散 蚬壳胃散说白滚水送又说冷水 大便遇水就散什么原因 散水是什么意思 苦参水杨酸散 散讲三水 新三水网站 散水伸缩缝 气乘风则散界水则止出自哪里 水荷包蛋怎么做不散 室外散水做法图片 散炮的用法 散炮 鲫鱼散炮配方 散炮的正确抛竿方法 笔记本散热 暖气散热片 散热硅胶 液冷散热 散热硅脂 手机散热 电脑散热 散热保护膜 散热 戴尔散热 散热笔记本 显卡散热 散热板 散热方式 笔记本散热设备 笔记本电脑散热 电脑散热不好怎么办 手机散热大师

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里