HDU_1401——分步双向BFS,八进制位运算压缩,map存放hash

Problem Description

Solitaire is a game played on a chessboard 8x8. The rows and columns of the chessboard are numbered from 1 to 8, from the top to the bottom and from left to right respectively.
There are four identical pieces on the board. In one move it is allowed to:
> move a piece to an empty neighboring field (up, down, left or right),
> jump over one neighboring piece to an empty field (up, down, left or right). There are 4 moves allowed for each piece in the configuration shown above. As an example let's consider a piece placed in the row 4, column 4. It can be moved one row up, two rows down, one column left or two columns right.
Write a program that:
> reads two chessboard configurations from the standard input,
> verifies whether the second one is reachable from the first one in at most 8 moves,
> writes the result to the standard output.

 

Input

Each of two input lines contains 8 integers a1, a2, ..., a8 separated by single spaces and describes one configuration of pieces on the chessboard. Integers a2j-1 and a2j (1 <= j <= 4) describe the position of one piece - the row number and the column number respectively. Process to the end of file.

 

Output

The output should contain one word for each test case - YES if a configuration described in the second input line is reachable from the configuration described in the first input line in at most 8 moves, or one word NO otherwise.

 

Sample Input

4 4 4 5 5 4 6 5
2 4 3 3 3 6 4 6

 

Sample Output

YES

 

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

 struct point
 {
     int x,y;
     bool check()
         {
             if(x>= && x<= && y>= && y<=)
                 {
                     return true;
                 }
             return false;
         }
 };
 struct chess
 {
     point pos[];
     int step;
     bool check(int j)
         {
             for(int i=;i<;i++)
                 {
                     if(i!=j && pos[j].x==pos[i].x && pos[j].y==pos[i].y)
                         return true;
                 }
             return false;
         }
 }start,end;

 const int dir[][]={,,,-,,,-,};
 map<int,int>mapint;
 map<int,int>::iterator it;

 /*
 对棋盘状态进行进制压缩处理，棋子坐标(x,y)：0~7
 变成二进制：000~111，一共有4个棋子，所以一共有(x,y)坐标4个
 把棋型压缩成二进制形式，共24位。因为棋子都是相同的
 所以每次压缩前，都要对棋子坐标(x,y)进行排序，
 否则棋型相同棋子序号不同时，会出现不同的压缩状态
 */
 bool cmp(point a,point b)    //按x升序排序，如果x相等就按y升序排序
 {
     return a.x!=b.x ? a.x<b.x : a.y<b.y;    //>降序，<升序
 }
 int get_hash(point *temp)
 {
     int res = ;
     sort(temp,temp+,cmp);
     for(int i=;i<;i++)    //枚举棋子
         {
             res |= ( temp[i].x<<(*i) );
             res |= ( temp[i].y<<(*i+) );
         }
     return res;
 }

 bool BFS(int flag,chess temp)    //flag=1：从起点开始搜索，flag=2：终点开始
 {
     /*
     if(flag == 2)    //当从终点开始搜索时，先在存储起点搜索压缩状态的map容器中查找，是否已经到到达过终点
         {
             it = mapint.find(get_hash(temp.pos));
             if(it != mapint.end())
                 {
                     return true;
                 }
         }
     mapint[get_hash(temp.pos)] = flag;
     */
     queue<chess>que;
     que.push(temp);

     while(!que.empty())
         {
             temp = que.front();
             que.pop();
             if(temp.step >= )    //搜索步数不超过4步
                 {
                     continue;
                 }
             for(int i=;i<;i++)    //枚举方向
                 {
                     for(int j=;j<;j++)    //枚举棋子
                         {
                             chess next = temp;
                             next.step++;
                             next.pos[j].x += dir[i][];
                             next.pos[j].y += dir[i][];

                             if(!next.pos[j].check())    //判断棋子是否在棋盘内
                                 {
                                     continue;
                                 }
                             if(next.check(j))                //判断棋子j是否和其他棋子重叠
                                 {
                                     next.pos[j].x += dir[i][];    //重叠之后再前进一步
                                     next.pos[j].y += dir[i][];
                                     if(!next.pos[j].check())        //再次检查是否越界
                                         {
                                             continue;
                                         }
                                     if(next.check(j))                    //再次检查是否重叠
                                         {
                                             continue;
                                         }
                                 }

                             int hash = get_hash(next.pos);    //获得一种新的状态
                             it = mapint.find(hash);                //在容器中搜索这个新状态

                             if(flag == )    //从起点开始的搜索
                                 {    

                                     if(it == mapint.end())        //没找到，记录压缩状态，推入队列
                                         {
                                             mapint[hash] = flag;
                                             que.push(next);
                                         }

                                     else if(it -> second == )    //找到的是终点搜索过来的状态
                                         {
                                             return true;
                                         }

                                 }
                             else                //从终点开始的搜索
                                 {
                                     if(it == mapint.end())        //没找到，推入队列
                                         {
                                             que.push(next);        //不需要再生成压缩状态并记录了
                                         }
                                     else if(it -> second == )    //找到的是起点搜索过来的状态
                                         {
                                             return true;
                                         }
                                 }
                         }
                 }
         }
     return false;
 }

 int main()
 {
     while(~scanf("%d%d",&start.pos[].x,&start.pos[].y))
         {
             for(int i=;i<;i++)
                 {
                     scanf("%d%d",&start.pos[i].x,&start.pos[i].y);
                 }
             for(int i=;i<;i++)
                 {
                     scanf("%d%d",&end.pos[i].x,&end.pos[i].y);
                 }
             for(int i=;i<;i++)    //把棋盘坐标由1~8转化成0~7，方便进制压缩
                 {
                     start.pos[i].x--;    start.pos[i].y--;
                     end.pos[i].x--;    end.pos[i].y--;
                 }
             start.step = end.step = ;

             mapint[get_hash(start.pos)] = ;    //搜索之前先把初始压缩状态放入map容器，防止起点和终点一样的情况
             mapint[get_hash(end.pos)] = ;

             if(BFS(,start) || BFS(,end))
                 {
                     printf("YES\n");
                 }
             else
                 {
                     printf("NO\n");
                 }

             mapint.clear();    //狗日的一定要记住，容器什么的每次要清空
         }
     return ;
 }