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[][] = {,,-,,,,,-};
 const int pow[] = {,,,,,,,};

 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 * pow[*i];
         hash += a.chess[i].y * pow[*i+];
     }
     return hash;
 }

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

 bool BFS(int flag,node temp)
 {
     queue<node>que;
     que.push(temp);
     while(!que.empty())
     {
         temp = que.front();
         que.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_next = gethash(next);
                 it_2 = mapint.find(hash_next);

                 if(it_2 == mapint.end())
                 {
                     mapint[hash_next] = it_1->second + ;
                     que.push(next);
                 }
                 else if(it_2->second/ == -flag)
                 {
                     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--;
         }
         mapint[gethash(s)] = *+;
         mapint[gethash(e)] = *+;

         if(BFS(,s) || BFS(,e))
         {
             cout<<"YES"<<endl;
         }
         else
         {
             cout<<"NO"<<endl;
         }

         mapint.clear();
     }
     return ;
 }