Bloxorz很有意思的一个游戏(POJ3322)

Description

Little Tom loves playing games. One day he downloads a little computer game called 'Bloxorz' which makes him excited. It's a game about rolling a box to a specific position on a special plane. Precisely, the plane, which is composed of several unit cells, is a rectangle shaped area. And the box, consisting of two perfectly aligned unit cube, may either lies down and occupies two neighbouring cells or stands up and occupies one single cell. One may move the box by picking one of the four edges of the box on the ground and rolling the box 90 degrees around that edge, which is counted as one move. There are three kinds of cells, rigid cells, easily broken cells and empty cells. A rigid cell can support full weight of the box, so it can be either one of the two cells that the box lies on or the cell that the box fully stands on. A easily broken cells can only support half the weight of the box, so it cannot be the only cell that the box stands on. An empty cell cannot support anything, so there cannot be any part of the box on that cell. The target of the game is to roll the box standing onto the only target cell on the plane with minimum moves.

The box stands on a single cell
The box lies on two neighbouring cells, horizontally
The box lies on two neighbouring cells, vertically

After Little Tom passes several stages of the game, he finds it much harder than he expected. So he turns to your help.

Input

Input contains multiple test cases. Each test case is one single stage of the game. It starts with two integers R and C(3 ≤ R, C ≤ 500) which stands for number of rows and columns of the plane. That follows the plane, which contains R lines and C characters for each line, with 'O' (Oh) for target cell, 'X' for initial position of the box, '.' for a rigid cell, '#' for a empty cell and 'E' for a easily broken cell. A test cases starts with two zeros ends the input.

It guarantees that

• There's only one 'O' in a plane.
• There's either one 'X' or neighbouring two 'X's in a plane.
• The first(and last) row(and column) must be '#'(empty cell).
• Cells covered by 'O' and 'X' are all rigid cells.

Output

For each test cases output one line with the minimum number of moves or "Impossible" (without quote) when there's no way to achieve the target cell. 　

Sample Input

7 7
#######
#..X###
#..##O#
#....E#
#....E#
#.....#
#######
0 0

Sample Output

10

--------------------------------------------------------------------------------------------------------------
游戏很有意思，很智力~有兴趣可以到这个地方去玩玩~
关于这题，没有游戏中那种可以搭桥的情况~也就是说整个maze不会变，那总共就有500*500*5种状态了。
典型的BFS,可以记录其中某个格子的坐标，然后再用一个int变量来记录这个格子和另一个格子的相对位置。
0：上
1：右
2：下
3：左
以上是2个格子没有重叠的情况，假如重叠，那就把状态设为4。
当且仅当格子状态为4，并且位于终点时，才算成功。
4k的代码，写的我手有点麻~
-------------------------------------code----------------------------------------------------------------------

 
 

  
  
#include<iostream>
#include<queue>
using namespace std;
bool vis[500][500][5];
struct NODE
{
    int i,j,floor,state; 
};
int mv[4][2]={-1,0,0,1,1,0,0,-1},r,c,si[2],sj[2],k;
char maze[501][501];
void init ( )
{
    int i, j;
    k=0;
    memset(vis,0,sizeof(vis));
    for ( i=0 ; i<r ; i++ )
    {
        scanf("%s",maze[i]);
        for ( j=0 ; j<c ; j++ )
            if ( maze[i][j]=='X' )
                si[k]=i,sj[k++]=j;
    }
}
// 返回两个点的相对位置的状态
int mark ( int p1, int q1 , int p2 , int q2 )
{
    if ( p2-p1==-1 && q2-q1==0 )
        return 0;
    if ( p2-p1==0 && q2-q1==1 )
        return 1;
    if ( p2-p1==1 && q2-q1==0 )
        return 2;
    if ( p2-p1==0 && q2-q1==-1 )
        return 3;
}
void bfs ( )
{
    NODE temp,head;
    queue<NODE> que;
    int i,tm1,tn1,tm2,tn2;
    if ( k==1 )
    {
        head.i=si[0],head.j=sj[0];
        head.floor=0;
        head.state=4;
        que.push(head);
        vis[head.i][head.j][4]=vis[head.i][head.j][5]=true;
    }
    else
    {
        head.i=si[0],head.j=sj[0];
        head.floor=0;
        head.state=mark(si[0],sj[0],si[1],sj[1]);
        que.push(head);
        vis[si[0]][sj[0]][mark(si[0],sj[0],si[1],sj[1])]=vis[si[1]][sj[1]][mark(si[1],sj[1],si[0],sj[0])]=true;
    }
    while ( !que.empty() )
    {
        head=que.front();
//      cout<<"*******************************"<<endl;
        //if ( head.state>3 )
        //  cout<<head.i<<" "<<head.j<<" "<<head.floor<<" out"<<endl;
        //else
        //  cout<<head.i<<" "<<head.j<<" "<<head.i+mv[head.state][0]<<" "<<head.j+mv[head.state][1]<<" "<<head.floor<<" out"<<endl;
        que.pop() ;
        // 先考虑2个格子重叠的状态
        if ( head.state>3 )
            for ( i=0 ; i<4 ; i++ )
            {
                tm1=head.i+mv[i][0],tn1=head.j+mv[i][1];
                tm2=tm1+mv[i][0],tn2=tn1+mv[i][1];
                if ( tm2>=0 && tm2<r && tn2>=0 && tn2<c && maze[tm1][tn1]!='#' && maze[tm2][tn2]!='#' 
                    && !vis[tm1][tn1][mark(tm1,tn1,tm2,tn2)] && !vis[tm2][tn2][mark(tm2,tn2,tm1,tn1)] )
                {
                    vis[tm1][tn1][mark(tm1,tn1,tm2,tn2)]=vis[tm2][tn2][mark(tm2,tn2,tm1,tn1)]=true;
                    temp.i=tm1,temp.j=tn1,temp.floor=head.floor+1,temp.state=mark(tm1,tn1,tm2,tn2);
                    que.push(temp);
                    //if ( temp.state>3 )
                    //  cout<<temp.i<<" "<<temp.j<<" "<<temp.floor<<" in"<<endl;
                    //else
                    //  cout<<temp.i<<" "<<temp.j<<" "<<temp.i+mv[temp.state][0]<<" "<<temp.j+mv[temp.state][1]<<" "<<temp.floor<<" in"<<endl;
                }
            }
        else
        {
            for ( i=0 ; i<4 ; i++ )
            {
                if ( i==head.state || i==(head.state+2)%4 )
                    continue;
                tm1=head.i+mv[i][0],tn1=head.j+mv[i][1];
                tm2=tm1+mv[head.state][0],tn2=tn1+mv[head.state][1];
                if ( tm1>=0 && tm1<r && tn1>=0 && tn1<c  && tm2>=0 && tm2<r && tn2>=0 && tn2<c && maze[tm1][tn1]!='#' && maze[tm2][tn2]!='#' 
                    && !vis[tm1][tn1][head.state] && !vis[tm2][tn2][(head.state+2)%4] )
                {
                    vis[tm1][tn1][head.state]=vis[tm2][tn2][(head.state+2)%4]=true;
                    temp.i=tm1,temp.j=tn1,temp.floor=head.floor+1,temp.state=head.state;
                    que.push(temp);
                    //if ( temp.state>3 )
                    //  cout<<temp.i<<" "<<temp.j<<" "<<temp.floor<<" in"<<endl;
                    //else
                    //  cout<<temp.i<<" "<<temp.j<<" "<<temp.i+mv[temp.state][0]<<" "<<temp.j+mv[temp.state][1]<<" "<<temp.floor<<" in"<<endl;
                }
            }
            tm1=head.i+mv[(head.state+2)%4][0],tn1=head.j+mv[(head.state+2)%4][1];
            if ( tm1>=0 && tm1<r && tn1>=0 && tn1<c && maze[tm1][tn1]!='#' && maze[tm1][tn1]!='E' 
                && !vis[tm1][tn1][4] )
            {
                if (maze[tm1][tn1]=='O')
                {
                    printf("%d/n",head.floor+1);
                    return ;
                }
                vis[tm1][tn1][4]=true;
                temp.i=tm1,temp.j=tn1,temp.floor=head.floor+1,temp.state=4;
                que.push(temp);
                //if ( temp.state>3 )
                //      cout<<temp.i<<" "<<temp.j<<" "<<temp.floor<<" in"<<endl;
                //  else
                //      cout<<temp.i<<" "<<temp.j<<" "<<temp.i+mv[temp.state][0]<<" "<<temp.j+mv[temp.state][1]<<" "<<temp.floor<<" in"<<endl;
            }
            tm1+=3*mv[head.state][0],tn1+=3*mv[head.state][1];
            if ( tm1>=0 && tm1<r && tn1>=0 && tn1<c && maze[tm1][tn1]!='#' && maze[tm1][tn1]!='E' 
                && !vis[tm1][tn1][4] )
            {
                if ( maze[tm1][tn1]=='O' )
                {
                    printf("%d/n",head.floor+1);
                    return ;
                }
                vis[tm1][tn1][4]=true;
                temp.i=tm1,temp.j=tn1,temp.floor=head.floor+1,temp.state=4;
                que.push(temp);
                /*if ( temp.state>3 )
                        cout<<temp.i<<" "<<temp.j<<" "<<temp.floor<<" in"<<endl;
                    else
                        cout<<temp.i<<" "<<temp.j<<" "<<temp.i+mv[temp.state][0]<<" "<<temp.j+mv[temp.state][1]<<" "<<temp.floor<<" in"<<endl;*/
            }
        }
    }
    printf("Impossible/n");
}
int main ( )
{
    //freopen("ans.txt","w",stdout);
    while ( scanf("%d%d",&r,&c) && r && c )
    {
        init();
        bfs();
    }
}