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 <iostream>
 #include <algorithm>
 #include <queue>
 #include <map>
 using namespace std;

 const int dir[][] = {,,-,,,,,-};

 struct point
 {
     int x,y;
 };
 struct node
 {
     point chess[];

     bool check(int j)
     {
         if(chess[j].x>= && chess[j].x<= && chess[j].y>= && chess[j].y<=)
         {
             for(int i=;i<;i++)
             {
                 if(i!=j && chess[i].x==chess[j].x && chess[i].y==chess[j].y)
                 {
                     return false;
                 }
             }
             return true;
         }
         return false;
     }
 }s,e;

 bool cmp(const struct point& a,const struct point& b)
 {
     if(a.x == b.x)
     {
         return a.y<b.y;
     }
     return a.x<b.x;
 }
 int gethash(node& a)
 {
     sort(a.chess, a.chess+, cmp);
     int hash = ;
     for(int i=; i<; i++)
     {
         hash |= a.chess[i].x << (*i);
         hash |= a.chess[i].y << (*i+);
     }
     return hash;
 }

 map<int,int>mapint;
 map<int,int>::iterator it_1,it_2;

 bool BFS(void)
 {
     queue<node>que[];

     que[].push(s);
     que[].push(e);
     mapint[gethash(s)] = *+;
     mapint[gethash(e)] = *+;

     int sign;
     while(!que[].empty() || !que[].empty())
     {
         if(que[].size() < que[].size())
         {
             sign = que[].empty() ? :;
         }
         else
         {
             sign = que[].empty() ? :;
         }

         node temp = que[sign].front();
         que[sign].pop();

         it_1 = mapint.find(gethash(temp));

         if((it_1->second)% >= )    //移动步数超过4步
         {
             continue;
         }
         for(int i=;i<;i++)
         {
             for(int j=;j<;j++)
             {
                 node next = temp;
                 next.chess[i].x += dir[j][];
                 next.chess[i].y += dir[j][];

                 if(!next.check(i))        //重叠或者越界
                 {
                     next.chess[i].x += dir[j][];
                     next.chess[i].y += dir[j][];
                     if(!next.check(i))    //重叠或者越界
                     {
                         continue;
                     }
                 }

                 int hash = gethash(next);
                 it_2 = mapint.find(hash);

                 if(it_2 == mapint.end())
                 {
                     mapint[hash] = it_1->second + ;
                     que[sign].push(next);
                 }
                 else if(it_2->second/ == -sign)
                 {
                     return true;
                 }
             }
         }
     }
     return false;
 }

 int main()
 {
     while(cin>>s.chess[].x>>s.chess[].y)
     {
         for(int i=; i<; i++)
         {
             cin>>s.chess[i].x>>s.chess[i].y;
         }
         for(int i=; i<; i++)
         {
             cin>>e.chess[i].x>>e.chess[i].y;
         }
         for(int i=;i<;i++)
         {
             s.chess[i].x--; s.chess[i].y--;
             e.chess[i].x--; e.chess[i].y--;
         }

         if(BFS())
         {
             cout<<"YES"<<endl;
         }
         else
         {
             cout<<"NO"<<endl;
         }
         mapint.clear();
     }
     return ;
 }