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[4][2] = {1,0,-1,0,0,1,0,-1};
const int pow[8] = {1,8,64,512,4096,32768,262144,2097152};

struct point
{
    int x,y;
};
struct node
{
    point chess[4];
    
    bool check(int j)
    {
        if(chess[j].x>=0 && chess[j].x<=7 && chess[j].y>=0 && chess[j].y<=7)
        {
            for(int i=0;i<4;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+4, cmp);
    int hash = 0;
    for(int i=0; i<4; i++)
    {
        hash += a.chess[i].x * pow[2*i];
        hash += a.chess[i].y * pow[2*i+1];
    }
    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)%10 >= 4)    //移动步数超过4步 
        {
            continue;
        }
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4;j++)
            {
                node next = temp;
                next.chess[i].x += dir[j][0];
                next.chess[i].y += dir[j][1];
                
                if(!next.check(i))    //重叠或者越界 
                {
                    next.chess[i].x += dir[j][0];
                    next.chess[i].y += dir[j][1];
                    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 + 1;
                    que.push(next);
                }
                else if(it_2->second/10 == 1-flag)
                {
                    return true;
                }
            }
        }
    }
    return false;
}

int main()
{
    while(cin>>s.chess[0].x>>s.chess[0].y)
    {
        for(int i=1;i<4;i++)
        {
            cin>>s.chess[i].x>>s.chess[i].y;
        }
        for(int i=0;i<4;i++)
        {
            cin>>e.chess[i].x>>e.chess[i].y;
        }
        for(int i=0;i<4;i++)
        {
            s.chess[i].x--;s.chess[i].y--;
            e.chess[i].x--;e.chess[i].y--;
        }
        mapint[gethash(s)] = 10*0+0;
        mapint[gethash(e)] = 10*1+0;
        
        if(BFS(0,s) || BFS(1,e))
        {
            cout<<"YES"<<endl;
        }
        else
        {
            cout<<"NO"<<endl;
        }
        
        mapint.clear();
    }
    return 0;
}