ACM/ICPC 之 BFS+状态压缩(POJ1324(ZOJ1361))

求一条蛇到(1,1)的最短路长，题目不简单，状态较多，需要考虑状态压缩，ZOJ的数据似乎比POj弱一些

---

POJ1324(ZOJ1361)-Holedox Moving

　　题意：一条已知初始状态的蛇，求其到(1,1)的最短路长

　　题解：开始做的时候用BFS暴力做了一次，结果RE了，后来看了其他的题解和discuss才转向状态压缩。也看到有人用A*做出来了。

　　　　现在简要介绍一下状态压缩的思路：

　　　　　　由于蛇身最长只有8，可以利用两条相邻蛇身坐标确定其相对方向(四个方向)，两位二进制可以表示

　　　　　　这样 一个蛇头坐标+14位二进制数 就可以确定一个蛇身状态

　　　　　　而后状态重复则可以进行剪枝，这是一种很好的优化。

　　　　这里我用一个方向数组mov[4][2]简化代码，而且不需要自己考虑太多方向的先后顺序及分支。

 //蛇的移动-求达到终点的最短路长
 //BFS+状态压缩
 //两位二进制(4个方向)记录后一个蛇身相对前一个的位置，以此将蛇身记录为数值
 //POJ:Time: 1297Ms    Memory: 25440K
 //ZOJ:Time: 350Ms    Memory: 31388K
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 using namespace std;
 const int MAX = ;
 const int MAXN = ;
 const int MAXLEN =  <<  + ;
 struct Snake{
     int x, y;
 }snake[];
 struct State {
     Snake h;    //头部坐标
     unsigned hash;
     int step;
 }s[MAXN];
 int row, col, len;
 bool map[MAX][MAX];    //是否存在障碍
 bool v[MAX][MAX][MAXLEN];    //状态记录
 int mov[][] = { {,}, {-,}, {,}, {,-} };
 int get_next_hash(int hash, Snake pre, Snake next)
 {
     const int INF = ( << ((len - ) << )) - ;
     int dx = pre.x - next.x;
     int dy = pre.y - next.y;
     for (int i = ; i < ; i++)
     {
         if (mov[i][] == dx && mov[i][] == dy)
         {
             hash <<= ;
             hash &= INF;
             hash |= i;
             break;
         }
     }
     return hash;
 }
 /*是否撞到自己或障碍*/
 bool judge(State cur, Snake t)
 {
     if (t.x >  && t.x <= row && t.y >  && t.y <= col && !map[t.x][t.y])
     {
         for (int i = ; i < len; i++)
         {
             int key = ( << ) - ;
             key &= cur.hash;
             cur.hash >>= ;
             cur.h.x += mov[key][];
             cur.h.y += mov[key][];
             if (cur.h.x == t.x && cur.h.y == t.y)    //撞到了
                 return false;
         }
         return true;
     }
     return false;
 }
 void bfs()
 {
     int front = , tail = ;
     s[].step = ;
     if (s[].h.x ==  && s[].h.y == )
     {
         printf("0\n");
         return;
     }
     while (front < tail)
     {
         for (int i = ; i < ; i++)
         {
             Snake t;
             t.x = s[front].h.x + mov[i][];
             t.y = s[front].h.y + mov[i][];
             if (t.x ==  && t.y == )
             {
                 printf("%d\n", s[front].step + );
                 return;
             }
             if (judge(s[front], t))
             {
                 s[tail].hash = get_next_hash(s[front].hash, s[front].h, t);
                 if (!v[t.x][t.y][s[tail].hash])
                 {
                     v[t.x][t.y][s[tail].hash] = true;
                     s[tail].h = t;
                     s[tail].step = s[front].step + ;
                     tail++;
                 }
             }
         }
         front++;
     }
     printf("-1\n");
 }
 //初始化蛇的开始位置
 void init_snake()
 {
     s[].h = snake[];
     s[].hash = ;
     for (int i = len - ; i > ; i--)
         s[].hash = get_next_hash(s[].hash, snake[i], snake[i - ]);
     v[s[].h.x][s[].h.y][s[].hash] = true;
 }
 int main()
 {
     int counter = ;
     while (scanf("%d%d%d", &row, &col, &len), row && col && len)
     {
         memset(map, false, sizeof(map));
         memset(v, false, sizeof(v));
         for (int i = ; i < len; i++)
             scanf("%d%d", &snake[i].x, &snake[i].y);
         int m, x, y;
         scanf("%d", &m);
         for (int i = ; i < m; i++)
         {
             scanf("%d%d", &x, &y);
             map[x][y] = true;
         }
         init_snake();
         printf("Case %d: ", ++counter);
         bfs();
     }
     return ;
 }