POJ 3322 Bloxorz I(BFS, 改编自同名游戏，很不错的一题)

POJ 3322 Bloxorz I(BFS, 改编自同名游戏，很不错的一题)

Bloxorz I

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 2624		Accepted: 882

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

Source

POJ Monthly--2007.08.05, Rainer

此题是标准的BFS,但是要注意优化，写的不好代码很容易超过5000B.
1.首先是状态压缩，积木可以立起来，也可以朝向上下左右躺下，其实向左躺和向右躺下实际上是同一种状态，向上躺和向下躺亦然，所以本题可以压缩成3个状态，这里用1表示直立，2表示横躺，3表示竖躺，可以节省大量空间花费；
2.用队列进行广搜的时候最好不要使用STL的queue容器，由于queue的初始值有限，搜索的时候需要大量移动内存中的数据，效率比较低，不妨手工直接模拟一个队列。
3.在搜索的时候，由于状态空间比较大，如果一一列出，代码过于冗长，比较好的方法是用一个三维矩阵来存储状态之间的关系，这样搜索的过程可以只用一个for循环来实现，代码十分精简。
4.最好进行初始化，读入数据的时候将其转化成整数，这样操作起来比较方便。

下面是我的代码：

// This is the sorce code for POJ 3322
// created by abilitytao
// Time:2009年8月16日22:33:08
// special thanks to Rainer
#include < iostream >
using   namespace  std;
#define  MAX 502
#define  LINEMAX 9000000

struct  node
{
    int x,y;
    int step;
    int state;//1代表直立，2代表水平放，3代表垂直放
} ;

bool  visit[MAX][MAX][ 4 ];
int  graph[MAX][MAX]; // 0->empty cell，1->weak cell,2->rigid cell
node l[LINEMAX];

int  dir[ 3 ][ 4 ][ 3 ] = {{{0,-1,2},{-2,0,1},{0,2,2},{1,0,1}},
                {{0,-1,0},{-1,0,-1},{0,1,0},{2,0,-1}},
                {{0,-2,-2},{-1,0,0},{0,1,-2},{1,0,0}}} ;




inline  bool  check( int  x, int  y, int  state)
{
    if(graph[x][y]==0) return false;
    if(state==1&&graph[x][y]==1) return false;
    else if(state==2&&graph[x+1][y]==0)    return false;
    else if(state==3&&graph[x][y-1]==0)    return false;
    return true;
}



inline node inputgraph( int  r, int  c, int   & endx, int   & endy)
{

    int i,j;
    int len;
    char temp[MAX];
    int x1=0,y1=0;
    int x2=0,y2=0;
    int flag=0;
    node s;    
    memset(graph,0,sizeof(graph));//Graph矩阵清0
    memset(visit,0,sizeof(visit));//visit矩阵清0
    for(i=1;i<=r;i++)
    {

        scanf("%s",temp);
        len=strlen(temp);
        for(j=0;j<len;j++)
        {
            if(temp[j]=='#') graph[j+1][i]=0;
            else if(temp[j]=='E') graph[j+1][i]=1;
            else if(temp[j]=='.') graph[j+1][i]=2;
            else if(temp[j]=='X'&&flag==0)
            {
                graph[j+1][i]=2;
                x1=j+1;y1=i;
                flag=1;
            }
            else if(temp[j]=='X'&&flag==1)
            {
                graph[j+1][i]=2;
                x2=j+1;y2=i;
            }
            else if(temp[j]=='O')
            {

                graph[j+1][i]=2;
                endx=j+1;
                endy=i;
            }
        }
    }
    if(x1!=0&&x2!=0&&y1!=0&&y2!=0)
    {
        if(y1<y2) {s.x=x1;s.y=y2;s.state=3;}
        else if(x1<x2) {s.x=x1;s.y=y1;s.state=2;}
    }
    else {s.x=x1;s.y=y1;s.state=1;}
    s.step=0;
    return s;
}


int  main()
{
    
    int r,c;
    int i,j;
    int endx,endy;
    int newx,newy;
    int newstate;
    while(scanf("%d%d",&r,&c))
    {
        
        if(r==0&&c==0)
            break;
        int front=1;
        int rear=1;
        l[front]=inputgraph(r,c,endx,endy);
        visit[l[front].x][l[front].y][l[front].state]=1;
        while(front<=rear)
        {
            if(l[front].x==endx&&l[front].y==endy&&l[front].state==1)
            {
                printf("%d\n",l[front].step);
                break;
            }

            for(j=0;j<4;j++)
            {
                newx=l[front].x+dir[l[front].state-1][j][0];
                newy=l[front].y+dir[l[front].state-1][j][1];
                newstate=l[front].state+dir[l[front].state-1][j][2];
                if(!visit[newx][newy][newstate]&&check(newx,newy,newstate))
                {
                    
                    rear=rear++;
                    l[rear].x=newx;
                    l[rear].y=newy;
                    l[rear].state=newstate;
                    visit[newx][newy][newstate]=1;
                    l[rear].step=l[front].step+1;
                }
            }
        
        front++;
        }
        if(front>rear)
            printf("Impossible\n");
    }
    return 0;
}