ACM/ICPC 之 BFS-广搜进阶-八数码(经典)(POJ1077+HDU1043)

八数码问题也称为九宫问题。(本想查查历史，结果发现居然没有词条= =，所谓的历史也就不了了之了)

在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。
要求解决的问题是：
　　给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。

所谓问题的一个状态就是棋子在棋盘上的一种摆法。棋子移动后，状态就会发生改变。解八数码问题就是找出从初状态到目标状态所经过的一系列中间状态。
八数码问题一般使用搜索法来解，例如广度优先搜索法、深度优先搜索法、A*算法等。

用图像来表示就是：

---

POJ和HDU上面有两道相同的题目，不过测试数据是HDU比较强
先来看看POJ的解法

　　POJ上是单组数据即可，所以只需要输入一次，然后一次正向广度优先搜索-BFS(在线)就行了，至于每一个八数码的状态保存方法，用康托展开的方式保存是比较明智的(没有接触过的同学可以问问度娘，本质是使用十进制数保存八进制数)，注意不要使用string类型，string的速度很慢，会TLE，直接使用字符串就行了

Code如下

 //POJ1077-经典BFS-八数码
 //单组数据(HDU1043多组数据较强)
 //正向搜索(用string类型会TLE,所以改用字符串+父结点及方向标记)
 //Time:313Ms    Memory:9870K

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<queue>
 using namespace std;

 #define MAX 400000
 #define AIM 46234    //123456780对应的康托Hash值

 bool v[MAX];
 char path[MAX];    //总路径
 int len;    //路径长

 /*udlr*/
 char *dir = "udlr";    //正向搜索
 int mov[][] = { { -,  }, { ,  }, { , - }, { ,  } };

 //八数码状态结构体
 struct Node{
     int s[];
     int loc;    //空位
     int status;    //Hash值-排列值
     int fa;    //记录父状态
     char d;    //到此状态的移动方向
 }n[MAX];

 int fac[] = { , , , , , , , , ,  };
 //对序列ncur.s[9]康托展开-返回Hash值
 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 + ;
 }

 /*反向记录路径*/
 void count_path(Node end)
 {
     int f = end.fa;
     len = ;
     path[len++] = end.d;
     while (f)
     {
         path[len++] = n[f].d;
         f = n[f].fa;
     }
 }

 bool BFS()
 {
     memset(v, , sizeof(v));
     Node next;    //下一临时状态
     int head = , tail = ;

     n[].status = cantor(n[].s);
     v[n[].status] = true;
     while (head <= tail)    //模拟队列
     {
         if (n[head].status == AIM)    //达到AIM
         {
             count_path(n[head]);
             return true;
         }
         //计算二维坐标
         int x = n[head].loc / ;
         int y = n[head].loc % ;
         for (int i = ; i < ; i++)
         {
             int tx = x + mov[i][];
             int ty = y + mov[i][];
             if (tx <  || tx> || ty <  || ty>)continue;
             //新状态更新
             next = n[head];
             next.loc = tx *  + ty;    //计算新空位
             next.s[n[head].loc] = next.s[next.loc];    //原空位替换
             next.s[next.loc] = ;    //新空位
             next.fa = head;
             next.d = dir[i];
             next.status = cantor(next.s);
             //判重并入队
             if (!v[next.status])
             {
                 v[next.status] = true;
                 if (next.status == AIM)
                 {
                     count_path(next);
                     return true;
                 }
                 n[++tail] = next;
             }
         }
         head++;
     }
     return false;
 }

 int main()
 {
     /*input*/
     char ch[];
     for (int i = ; i < ; i++)
     {
         scanf("%s",ch);
         if (!strcmp(ch,"x"))
         {
             n[].s[i] = ;
             n[].loc = i;
         }
         else n[].s[i] = ch[] - '';
     }

     /*output*/
     if (BFS())
     {    //反向输出路径
         for (int i = len - ; i>=; i--)
             printf("%c", path[i]);
         printf("\n");
     }
     else
         printf("unsolvable\n");
     return ;
 }

---

HDU解法如下：
　　HDU上是多组数据，因此 在线BFS 的方法会重复计算很多次，今天重点说说广度优先搜索，因此我们用 离线BFS 方法(也就是打表的思想)计算出所有路径并保存，
之后输入状态只需要计算出其康托逆展开的Hash值，就可以直接输出对应的路径了

 //HDU1043-经典BFS-八数码
 //多组数据-需要计算全部路径后直接输出(POJ1077数据较弱)
 //反向搜索+打表(离线)
 //Time:109Ms    Memory:25412K

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<queue>
 using namespace std;

 #define MAX 400000
 #define AIM 46234    //123456780对应的康托Hash值

 bool v[MAX];
 char path[MAX][];    //总路径
 int len;    //路径长

 /*udlr*/
 char *dir = "durl";    //反向搜索
 int mov[][] = { { -,  }, { ,  }, { , - }, { ,  } };

 //八数码状态结构体
 struct Node{
     int s[];
     int loc;    //空位
     int status;    //Hash值-排列值
     int fa;    //记录父状态
     char d;    //到此状态的移动方向
 }n[MAX];

 int fac[] = { , , , , , , , , ,  };
 //康托逆展开-返回Hash值
 int Inverse_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 + ;
 }

 /*反向记录路径*/
 void count_path(Node end)
 {
     int status = end.status;
     int f = end.fa;
     len = ;
     path[status][len++] = end.d;
     while (f)
     {
         path[status][len++] = n[f].d;//方向记录
         f = n[f].fa;    //查找父结点
     }
 }

 void BFS()
 {
     memset(v, , sizeof(v));
     Node next;    //下一临时状态
     int head = , tail = ;
     /*目标状态*/
     for (int i = ; i < ; i++)
         n[].s[i] = i + ;
     n[].s[] = ;
     n[].loc = ;
     n[].status = AIM;
     v[AIM] = true;
     while (head <= tail)    //模拟队列
     {
         //计算二维坐标
         int x = n[head].loc / ;
         int y = n[head].loc % ;
         for (int i = ; i < ; i++)    //遍历四方向
         {
             int tx = x + mov[i][];
             int ty = y + mov[i][];
             if (tx <  || tx> || ty <  || ty>)continue;
             //新状态更新
             next = n[head];
             next.loc = tx *  + ty;    //计算新空位
             next.s[n[head].loc] = next.s[next.loc];    //原空位替换
             next.s[next.loc] = ;    //新空位
             next.fa = head;
             next.d = dir[i];
             next.status = Inverse_cantor(next.s);
             //判重并入队
             if (!v[next.status])
             {
                 v[next.status] = true;
                 count_path(next);
                 n[++tail] = next;
             }
         }
         head++;
     }
 }

 int main()
 {
     /* BFS-打表 */
     BFS();
     /*input*/
     char ch[];
     Node cur;
     while (scanf("%s", ch) != EOF)
     {
         if (!strcmp(ch, "x"))
             cur.s[] = , cur.loc = ;
         else cur.s[] = ch[] - '';
         for (int i = ; i < ; i++)
         {
             scanf("%s", ch);
             if (!strcmp(ch, "x"))
                 cur.s[i] = , cur.loc = i;
             else cur.s[i] = ch[] - '';
         }
         cur.status = Inverse_cantor(cur.s);

         /*output*/
         if (v[cur.status])
             printf("%s\n", path[cur.status]);
         else
             printf("unsolvable\n");
     }
     return ;
 }

---