POJ 3322 Bloxorz I（BFS）

题意：

要把x所在地方的盒子翻滚到O处，最少需要的滚动次数。

思路：

BFS 求最短路径，问题的关键是如何对盒子翻转时，移动状态的一个设计，开了一个三维数组。

#include <iostream>
#include <algorithm>
#include <deque>
using namespace std;

struct ST {
    int x, y;           // x, y 代表右下角的坐标位置
    int step, state;    // state = 0 竖立, state = 1 水平, state = 2 竖直
    ST() {}
    ST(int _x, int _y, int _step, int _state) 
        : x(_x), y(_y), step(_step), state(_state) {}
};

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

char grid[510][510];
bool vis[510][510][3];
int row, col;

bool judge(int x, int y, int state) {
    if (0 < x && x <= row && 0 < y && y <= col && grid[x][y] != '#') {
        if (state == 0 && grid[x][y] != 'E') {
            return true;
        }
        if (state == 1 && 1 < y && grid[x][y-1] != '#') {
            return true;
        }
        if (state == 2 && 1 < x && grid[x-1][y] != '#') {
            return true;
        }
    }
    return false;
}

int bfs(const ST& src, const ST& dst) {
    deque<ST> Q;
    Q.push_back(src);
    vis[src.x][src.y][src.state] = true;

    while (!Q.empty()) {
        ST u = Q.front();
        Q.pop_front();

        if (u.x == dst.x && u.y == dst.y && u.state == dst.state)
            return u.step;

        for (int i = 0; i < 4; i++) {
            int x = u.x + dir[u.state][i][0];
            int y = u.y + dir[u.state][i][1];
            int state = dir[u.state][i][2];
            if (!vis[x][y][state] && judge(x, y, state)) {
                vis[x][y][state] = true;
                Q.push_back(ST(x, y, u.step + 1, state));
            }
        }
    }
    return -1;
}

int main() {
    while (scanf("%d%d", &row, &col) && row && col) {
        ST src, dst;
        bool cflag = false;
        for (int i = 1; i <= row; i++) {
            scanf("%s", &grid[i][1]);
            for (int j = 1; j <= col; j++) {
                if (grid[i][j] == 'O') {
                    dst.x = i, dst.y = j, dst.state = 0;
                } else if (grid[i][j] == 'X') {
                    if (!cflag) {
                        cflag = true;
                        src.x = i, src.y = j, src.state = 0;
                    } else {
                        if (src.x == i) {
                            src.y = max(src.y, j);
                            src.state = 1;
                        } else if (src.y == j) {
                            src.x = max(src.x, i);
                            src.state = 2;
                        }
                    }
                }
                vis[i][j][0] = vis[i][j][1] = vis[i][j][2] = false;
            }
        }
        src.step = 0;
        int ans = bfs(src, dst);
        if (ans == -1) 
            printf("Impossible\n");
        else
            printf("%d\n", ans);
    }
    return 0;
}