POJ3322 Bloxorz I

Bloxorz I

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 5993		Accepted: 1976

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

 

 

【翻译】

（非博主翻译）

šBloxorz是一个风靡世界的小游戏。Bloxorz的地图是一个N行M列的矩阵，每个位置可能是硬地（用.表示）、易碎地面（用E表示）、禁地（用#表示）、起点（用X表示）或终点（用O表示）。你的任务是操作一个1*1*2的长方体。这个长方体在地面上有两种放置形式，“立”在地面上（1*1的面接触地面）或者“躺”在地面上（1*2的面接触地面）。在每一步操作中，可以按上下左右四个键之一。按下之后，长方体向对应的方向沿着棱滚动90度。任意时刻，长方体不能有任何部位接触禁地（否则就会掉下去），并且不能立在易碎地面上（否则会因为压强太大掉下去）。X标识长方体的起始位置，地图上可能有一个X或者两个相邻的X。地图上唯一的一个O标识目标位置。求把长方体移动到目标位置（即立在O上）所需要的最少步数。如果无解，输出Impossible。在移动过程中，X和O标识的位置都可以看作是硬地被利用，3<=N,M<=500。

【题解】

爆搜，没啥好说的

 

Code

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <algorithm>

inline void read(int &x)
{
    x = 0;char ch = getchar();
    char c = ch;
    while(ch > '9' || ch < '0')c = ch, ch = getchar();
    while(ch <= '9' && ch >= '0')x = x * 10 + ch - '0', ch = getchar();
    if(c == '-')x = -x;
}
inline int min(int a, int b){return a > b ? b : a;}
inline int max(int a, int b){return a > b ? a : b;}

const int INF = 0x3f3f3f3f; 
const int MAXN = 1000 + 10;
const int MAXM = 1000 + 10;

//0:一个点竖着，记录这个点的下标
//1：竖着躺 记录上面的那个点的坐标
//2：横着躺 记录左边的那个点的坐标 
const int dx[3][4] = {{-2,1,0,0},{-1,2,0,0},{0,0,-1,1}}; 
const int dy[3][4] = {{0,0,-2,1},{0,0,-1,1},{-1,2,0,0}};
const int dz[3][4] = {{1,1,2,2},{0,0,1,1},{0,0,2,2}};

char g[MAXN][MAXM];
int n,m,sx,sy,sz,ex,ey;

struct Point
{
    int x,y,z,step;
    Point(){}
    Point(int _x, int _y, int _z, int _step){x = _x;y = _y;z = _z;step = _step;}
};

std::queue<Point> q;
int b[MAXN][MAXM][4];

int Isok(Point a)
{
    if(a.z == 0 && !(a.x > n || a.x < 1 || a.y > m || a.y < 1) && !b[a.x][a.y][a.z] && g[a.x][a.y] != 'E' && g[a.x][a.y] != '#')return 0;
    if(a.z == 1 && !(a.x < 1 || a.x + 1 > n || a.y < 1 || a.y > m) && !b[a.x][a.y][a.z] && g[a.x][a.y] != '#' && g[a.x + 1][a.y] != '#')return 0;
    if(a.z == 2 && !(a.x < 1 || a.x > n || a.y < 1 || a.y + 1 > m) && !b[a.x][a.y][a.z] && g[a.x][a.y] != '#' && g[a.x][a.y + 1] != '#')return 0;
    return 1;
}

int bfs()
{
    memset(b, 0, sizeof(b));
    while(q.size())q.pop();
    q.push(Point(sx, sy, sz, 0));
    Point now;
    b[sx][sy][sz] = true;
    while(q.size())
    {
        now = q.front();q.pop();
        for(int i = 0;i < 4;++ i)
        {
            Point tmp;
            tmp = Point(now.x + dx[now.z][i],now.y + dy[now.z][i], dz[now.z][i], now.step + 1);
            if(Isok(tmp)) continue;
            if(tmp.x == ex && tmp.y == ey && !tmp.z)return tmp.step;
            q.push(tmp);
            b[tmp.x][tmp.y][tmp.z] = 1;
        }
    }
    return -1;
}

int main()
{
    while (scanf("%d %d", &n, &m) && n)
    {
        for(int i = 1;i <= n;++ i)
            scanf("%s", g[i] + 1);
        for (int i = 1;i <= n;++ i)
        {
            for (int j = 1;j <= m;++ j)
                if (g[i][j] == 'O')
                    ex = i,ey = j;
                else if (g[i][j] == 'X' && g[i + 1][j] == 'X')
                {
                    sx = i,sy = j;
                    g[i + 1][j] = '.';
                    sz = 1;
                }
                else if(g[i][j] == 'X' && g[i][j + 1] == 'X')
                {
                    g[i][j + 1] = '.';
                    sx = i,sy = j;
                    sz = 2;
                }
                else if(g[i][j] == 'X')
                {
                    sx = i,sy = j;
                    sz = 0;
                }
        }
        int ans = bfs();
        if(ans == -1)puts("Impossible\n");
        else printf("%d\n", ans);
    }
    return 0;
}