A*算法——启发式搜索

A*算法

本质还是搜索：加了优化而已

关于这个优化，听到两种说法：

---

1.剪枝

通过判断预计最少还要几步，加强版剪枝

比如说一个经典剪枝：

如果

步数≥已知最小值

则

剪枝

升级|

V

如果

步数+最少还要几步≥已知最小值

则

剪枝

---

2.修改顺序

每次搜索时优先考虑最有可能是最有解的选项

（启发的感觉）

可以建个优先队列来维护每次取到的f最小

注：

f=g+h

g为已经用的步数

h为预计要用的步数

——我倾向于这一种，因为感觉更加神奇，而且写出来是非递归（递归的心理阴影）——

---

下面来一道水题：BFS轻松过的我来写A*

http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=19699

poj3984

事实上既然m n都是5，BFS说不定会比A*更优

但是说明问题就好

 #include <cstdio>
 #include <queue>
 #include <cmath>
 using namespace std;
 struct hh
 {
     int x,y,z;
 };
 priority_queue<hh> q;
 int n,m,t,x1,yy,x2,y2,_x,_y;
 bool ma[][],b[][],c[][];
 int f[][],g[][],h[][],fa[][],mo[][];
 bool operator <(hh a,hh b)
 {
     return a.z>b.z;
 }
 int add(int x,int y,int z)
 {
     hh p;
     p.x=y;p.y=z;p.z=x;
     q.push(p);
     return ;
 }
 int check(int x,int y,int z,int ff,int m)
 {
     if(!ma[x][y])
     {
         if(b[x][y])
         {
             if(g[x][y]>z)
             {
                 g[x][y]=z;
                 f[x][y]=z+h[x][y];
                 fa[x][y]=ff;
                 mo[x][y]=m;
                 add(f[x][y],x,y);
             }
         }
         else
         if(!c[x][y])
         {
             b[x][y]=true;
             g[x][y]=z;
             h[x][y]=abs(x-x2)+abs(y-y2);
             f[x][y]=g[x][y]+h[x][y];
             fa[x][y]=ff;
             mo[x][y]=m;
             add(f[x][y],x,y);
         }
     }
     return ;
 }
 int a_star()
 {
     check(x1,yy,,,);
     while(!q.empty())
     {
         int x=q.top().x;
         int y=q.top().y;
          q.pop();
         if((x==x2)&&(y==y2))
             return g[x][y];
         b[x][y]=false;
         c[x][y]=true;
         check(x-,y,g[x][y]+,x,y);
         check(x,y-,g[x][y]+,x,y);
         check(x+,y,g[x][y]+,x,y);
         check(x,y+,g[x][y]+,x,y);
     }
     return ;
 }
 int print(int x,int y)
 {
     if(fa[x][y]>)
         print(fa[x][y],mo[x][y]);
     printf("(%d, %d)\n",x-,y-);
     return ;
 }
 int main()
 {
     n=;m=;
     for(int i=;i<=n;i++)
         for(int j=;j<=m;j++)
             scanf("%d",&ma[i][j]);
     x1=;yy=;x2=;y2=;
     a_star();
     print(,);
     return ;
 }

代码不是很长，而且因为刚写完别的题，这里只是套了一下，很多代码是多余的

print递归输出不用管

a_star是主要程序（一看就知道）

check用于检查当前点周围一圈的点能不能加入队列，b表示点是否已经加入，c表示该点是否已经退出（已退出的不用管了）

记得在有更优值时更新

其实像是一种更加神奇的Dj——优先级是预计中的全路而不是已搜到的路，让程序能稍稍有点远见前面是坑还是会钻

这样写最神奇的地方在于它会向着目标一头栽过去，而不是像广搜只顾着预定的顺序，更加接近正常人的逻辑，因此搜索范围大大减小。

既然每个点都只能进队列一次，这个算法的复杂度最差情况下还是很低的