八数码问题的 A* 算法解答

 搞了一个通宵，终于搞定了！偶也！
Sicily 的 1379 那题，就是求给定的初始状态到目标状态，转换至少需要多少步。
例如状态

1 2 3

4 5 0

7 8 6

到达目标状态

1 2 3

4 5 6

7 8 0

只需一步（将 0 下移一格）即可。

在周赛的时候用广度搜索生成所有状态，耗时 0.6S 过了。但是这样不是聪明的办法（不过原理简单，实现也简单）。解这个问题的经典方法是使用 A* 算法进行启发式搜索，一般的人工智能原理的书都会介绍，在此不多说了。
看了下百度之星 2005 的比赛里 ACRush 的 代码，只看懂一小部分 orz... （注释都没有的！），不过也收获不少，hmhm。。也看了 Ray 的这篇 报告，受益匪浅。
下面是对该报告的一些 补充（最好自己先看看那篇报告和人工智能的书关于启发式搜索的那章）：
此题关键之一是使用曼哈顿距离来作启发函数。两个状态中对应的数字的的横向距离和纵向距离之和，定义为该数字的距离，而除了 0 的各个数字的距离之和定义为两个状态的距离，如上面提及的两个状态的距离为 1（只有数字 6 位置不同，而横向距离为 0， 纵向距离为 1）。
不难证明两个状态之间转换所需的步数不少于它们的距离。这样就满足了一般的 A* 算法的要求。采用评价函数 f (state) = g (state) + distance (state, goalState)，越小就越有希望到达目标状态，其中 g (state) 为从初始状态到达该状态的步数（随着搜索的进行，会发现到达该状态的更短的转换步骤，因此 g (state) 会逐渐减少至最小值 g* (state)）。
从开始状态开始搜索，按照将 0 上下左右移动的四种方式生成新的状态（当然要考虑可行性，如 0 已在最右边就不能再右移了）。在新的状态中找出评价函数值 f (state) 最小的状态来继续搜索（我们需要维护一个最小优先级队列 -- OPEN 表 -- 来找出 f 值最小的状态），直至搜索到目标状态。如果两个状态是可以互相达到的，那么可证 A* 算法一定可以找到最优解。
不难证明曼哈顿距离满足单调性，即在状态转换 state 1 -> 2 -> 3 中，distance (state1, state3) < distance (state2, state3) + cost (state1, state2)。
在满足这样的条件下，我们的搜索将满足以下两个有趣且有用的特性：
当要选择一个状态生成新状态时，它的 g (state) = g* (state)，即找到到达该状态的最少步数（如果你记录转换的上下左右记录的话，也将得到最少步数的转换步骤）。
选择的状态的评价函数值 f 是逐渐递增的。
如果不满足这个条件，那么在选择一个状态生成新状态时，新状态可能已经被生成过而且还被选择过，而达到这个新状态的步数可能会更少，即发现了更少的转换步骤，这样就有重复的工作了。而在满足条件下，一旦被选择则步数就已经是最少的了，就像最短路的 Dijkstra 算法那样。
而为了查询一个状态是否选择过，我们可以用一个 CLOSED 表 -- 来记录状态，在 C ++ 的 STL 中，我们可以选择 map 这种数据结构（一种平衡的二叉查找树），将一个状态对应的数字（如目标状态表示为 123456780）映射到对应的耗费 g 值。当然我们可以使用 hash_map 或者 trie 这两种数据结构，，或者自己实现一个哈希表，甚至使用“康托展开”直接映射到一个数组元素（后面几种数据结构占用内存较多）。这也是关键之一，我用自己实现的 trie 来做速度加快很多。另外预处理和使用一个变量 pos 来记录数字 0 的位置也很关键。
以下是我的代码：

//  八数码问题 A* 算法
//  by [email protected]
//  2007-12-10

#include  < cstdio >
#include  < queue >
#include  < map >
using   namespace  std;

const   int  ten [ 9 ]  =  { 100000000 ,  10000000 ,  1000000 ,  100000 ,  10000 ,  1000 ,  100 ,  10 ,  1 };
int  dist [ 9 ][ 9 ], diff [ 9 ][ 9 ];
//  dist [i][j] 为位置 i, j 的曼哈顿距离， diff [i][j] 为交换位置 i, j 使状态数改变的量
int  goalPos [ 9 ]  =  { 8 ,  0 ,  1 ,  2 ,  3 ,  4 ,  5 ,  6 ,  7 };
//  goalPos [i] 为目标状态中 i 的位置
int  goalNum  =   123456780 ;     //  目标状态的状态数
int  goalInv  =   0 ;         //  目标状态忽略 0 后的逆序数
int  state [ 9 ];             //  当前状态

struct  STATE{
     int  num, pos, g, h;     //  状态数，0 的位置，达到此状态的耗费，到达目标状态的启发函数值
    STATE ( int  num,  int  pos,  int  g,  int  h):num(num), pos(pos), g(g), h(h){}
     bool   operator   <  ( const  STATE &  other)  const      //  状态的评价函数等于耗费加上启发函数值
    {
         if  (g  +  h  ==  other.g  +  other.h)  return  h  >  other.h;     //  由于查询较少，此句帮助不大，可删掉
         return  g  +  h  >  other.g  +  other.h;
    }
};

void  preprocess ()         //  预处理
{
     for  ( int  i  =   0 ; i  <   9 ; i  ++ ){
        dist [i][i]  =   0 ;
         for  ( int  j  =   0 ; j  <  i; j  ++ ){
            dist [i][j]  =  dist [j][i]  =  abs (i  /   3   -  j  /   3 )  +  abs (i  %   3   -  j  %   3 );
            diff [i][j]  =  diff [j][i]  =  abs (ten [i]  -  ten [j]);
        }
    }
}

bool  noAns ( int  pos)         //  检查开始状态忽略 0 后的逆序数，如果和目标状态的逆序数奇偶性不一致，则没有解
{
     int  inv  =   0 ;
     for  ( int  i  =   0 ; i  <   9 ; i  ++ ){
         for  ( int  j  =   0 ; j  <  i; j  ++ ){
             if  (state [j]  >  state [i]) inv  ++ ;
        }
    }
     return  (inv  -  pos  -  goalInv)  %   2   !=   0 ;
}

int  heu ( int  pos)         //  计算启发函数值
{
     int  h  =   0 ;
     for  ( int  i  =   0 ; i  <   9 ; i  ++ ){
         int  j  =  goalPos [state [i]];
        h  +=  dist [i][j];
    }
     return  h  -  dist [pos][goalPos [ 0 ]];
}

int  astar ()
{
     // int cnt = 0;
     int  num  =   0 , pos  =   0 ;
     for  ( int  i  =   0 ; i  <   9 ; i  ++ ){
        scanf ( " %d " ,  & state [i]);
    }
     for  ( int  i  =   0 ; i  <   9 ; i  ++ ){        
        num  =  num  *   10   +  state [i];
    }
     for  ( int  i  =   0 ; state [i]; i  ++ ){
        pos  ++ ;
    }
     if  (noAns (pos))  return   - 1 ;     //  检查是否无解
    map  < int ,  int >  ng;         //  CLOSED 表，已扩展的结点（状态数 -> 到达该结点的最少耗费）
    priority_queue  < STATE >  q;     //  OPEN 表，待扩展的结点，但是仍然会存在已扩展的结点的记录
    STATE start(num, pos,  1 , heu (pos));     //  因为 map 对不存在的 key 返回 0，故初始状态的耗费应设为 1
    q.push (start);
     while  (q.size ()){
         // cnt ++;
        STATE top  =  q.top ();     //  考察 OPEN 表中评价函数值最小的结点
        q.pop ();
         int  pos  =  top.pos, num  =  top.num, g  =  top.g, h  =  top.h;
         if  (num  ==  goalNum){
             // printf ("%d ", cnt);
             return  g  -   1 ;     //  找到最优解，注意要减去 1
        }
         if  (ng [num])  continue ;     //  已经扩展过此结点则忽略
        ng [num]  =  g;         //  结点加入 CLOSED 表
         //  扩展此结点
         if  (pos  >   2 ){         //  move 0 up
             int  p  =  pos  -   3 ;
             int  i  =  num  /  ten [p]  %   10 , n  =  num  -  i  *  diff [pos][p];
             int  h2  =  h  -  dist [p][goalPos [i]]  +  dist [pos][goalPos [i]];
             if  ( ! ng [n]) q.push (STATE (n, p, g  +   1 , h2));
        }
         if  (pos  <   6 ){         //  move 0 down
             int  p  =  pos  +   3 ;
             int  i  =  num  /  ten [p]  %   10 , n  =  num  +  i  *  diff [pos][p];
             int  h2  =  h  -  dist [p][goalPos [i]]  +  dist [pos][goalPos [i]];
             if  ( ! ng [n]) q.push (STATE (n, p, g  +   1 , h2));
        }
         if  (pos  %   3 ){         //  move 0 left
             int  p  =  pos  -   1 ;
             int  i  =  num  /  ten [p]  %   10 , n  =  num  -  i  *  diff [pos][p];
             int  h2  =  h  -  dist [p][goalPos [i]]  +  dist [pos][goalPos [i]];
             if  ( ! ng [n]) q.push (STATE (n, p, g  +   1 , h2));
        }
         if  (pos  %   3   !=   2 ){     //  move 0 right
             int  p  =  pos  +   1 ;
             int  i  =  num  /  ten [p]  %   10 , n  =  num  +  i  *  diff [pos][p];
             int  h2  =  h  -  dist [p][goalPos [i]]  +  dist [pos][goalPos [i]];
             if  ( ! ng [n]) q.push (STATE (n, p, g  +   1 , h2));
        }
    }
     return   0 ;
}

int  main ()
{
     // freopen ("input.txt", "r", stdin);
    preprocess ();
     int  t;
    scanf ( " %d " ,  & t);
     while  (t  -- ){
        printf ( " %d  " , astar ());
    }
     return   0 ;
}

/*
Input
第一行是一个整数n，表示一共有多少组测试数据。
下面n行每行9个字符，用空格隔开，代表一个初始状态。
目标状态是 1 2 3 4 5 6 7 8 0。

Output
最小操作步数，无解时输出-1。

sample input
4
1 2 3 4 5 0 7 8 6
1 2 3 4 0 5 6 7 8
8 6 7 2 5 4 3 0 1
6 4 7 8 5 0 3 2 1

sample output
1
14
31
31

注意在 Release 模式下运行此程序，否则可能会很慢！
注意优先队列 priority_queue 是最大堆，因此在定义 STATE 结构的比较函数时要让 f 值较小的元素较大，
而当 f 相等的时候，启发函数 h 较小的状态应该优先考虑，故让该状态较大。
优先队列中仍然会存在一些 CLOSED 表中的状态，因为在生成新的状态时没有查找删除该新状态是否生成过。
*/