POJ1077 Eight —— A*算法

主页面：http://www.cnblogs.com/DOLFAMINGO/p/7538588.html

关于A*算法：g(n)表示从起点到任意节点n的路径花费，h(n)表示从节点n到目标节点路径花费的估计值（启发值），f(n) = g(n)+h(n)。
A*算法必须满足的条件（能不能满足由所选的h(n)估计方式决定）：每次扩展的节点的 f 值 >= 父节点的 f 值。

代码如下：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 #define ms(a,b) memset((a),(b),sizeof((a)))
 using namespace std;
 typedef long long LL;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int MOD = 1e9+;
 const int MAXN = 1e6+;
 #define AIM  1     //123456789的哈希值为1

 struct node
 {
     int status;
     int s[];
     int loc;
     int g,h,f;
     bool operator<(const node x)const{
         return f>x.f;
     }
 };

 int vis[MAXN], fac[] = { , , , , , , , , };
 int dir[][] = { -,, ,, ,-, , };
 char op[] = {'u', 'd', 'l', 'r'  };
 char path[MAXN];
 int pre[MAXN];

 int cantor(int s[])  //获得哈希函数值
 {
     int sum = ;
     for(int i = ; i<; i++)
     {
         int num = ;
         for(int j = i+; j<; j++)
             if(s[j]<s[i])
                 num++;
         sum += num*fac[-i];
     }
     return sum+;
 }

 int dis_h(int s[])  //获得曼哈顿距离
 {
     int dis = ;
     for(int i = ; i<; i++)
     if(s[i]!=)     //‘x’不能算进去，否则不能满足：“每次扩展的节点的 f 值 >= 父节点的 f 值小”
     {
         int x = i/, y = i%;
         int xx = (s[i]-)/, yy = (s[i]-)%;
         dis += abs(x-xx) + abs(y-yy);
     }
     return dis;
 }

 priority_queue<node>que;
 bool Astar(node now)
 {
     ms(vis,);
     while(!que.empty()) que.pop();

     now.status = cantor(now.s);
     now.g = ;
     now.h = dis_h(now.s);
     now.f = now.f + now.h;
     pre[now.status] = -;   //开始状态的上一个状态为-1，用于输出路径时“刹车”
     vis[now.status] = ;
     que.push(now);

     node tmp;
     while(!que.empty())
     {
         now = que.top();
         que.pop();
         if(now.status==AIM) //找到了123456789的状态
             return true;

         int x = now.loc/;
         int y = now.loc%;
         for(int i = ; i<; i++)
         {
             int xx = x + dir[i][];
             int yy = y + dir[i][];
             if(xx>= && xx<= && yy>= && yy<=)
             {
                 tmp = now;
                 tmp.s[x*+y] = tmp.s[xx*+yy];  //交换位置，下同
                 tmp.s[xx*+yy] = ;
                 tmp.status = cantor(tmp.s);
                 if(!vis[tmp.status])
                 {
                     vis[tmp.status] = ;
                     tmp.loc = xx*+yy;
                     tmp.g++;        //g
                     tmp.h = dis_h(tmp.s);   //h
                     tmp.f = tmp.g + tmp.h;      //f
                     pre[tmp.status] = now.status;   //tmp.status的上一个状态为now.status
                     path[tmp.status] = op[i];   //保存操作
                     que.push(tmp);
                 }
             }
         }
     }
     return ;
 }

 void Print(int status)
 {
     if(pre[status]==-) return;
     Print(pre[status]);     //追溯上一个状态
     putchar(path[status]);
 }

 int main()
 {
     char str[];
     while(gets(str))
     {
         node now;
         int cnt = ;
         for(int i = ; str[i]; i++)
         {
             if(str[i]==' ') continue;
             if(str[i]=='x') now.s[cnt] = , now.loc = cnt++;
             else  now.s[cnt++] = str[i]-'';
         }
         if(!Astar(now))
             puts("unsolvable");
         else
             Print(AIM), putchar('\n');
     }
 }