题目描述{:target=”_blank”}

游戏链接{:target=”_blank”}

算法

(广搜) $\mathcal O(nm)$

状态记录：

箱子共有三种状态：

• 立着，记录为 $0$
• 竖躺着，记录为 $1$
• 横躺着，记录为 $2$

坐标记录：

• 对于立着的，坐标记为其所立的位置。
• 对于竖躺着的，坐标记为其靠上的方块的坐标。
• 对于横躺着的，坐标记为其靠左的方块的坐标。

然后广搜即可。
广搜之前记录下三个状态扩展的偏移量，可简化代码。
详见代码注释。

时间复杂度

C++ 代码

#include <cstdio>
#include <cstring>

const int N = 505, // 地图边长
// 存三个状态分别向上下左右扩展的偏移量
dx[3][4] = {       // x 坐标的偏移量
    {-2, 0, 1, 0}, // 0 向上扩展，x - 2，向左 x 不变，向下 x + 1，向右 x 不变
    {-1, 0, 2, 0}, // 1，同上
    {-1, 0, 1, 0}  // 2
}, dy[3][4] = {    // y 坐标的偏移量
    {0, -2, 0, 1},
    {0, -1, 0, 1},
    {0, -1, 0, 2}
}, dl[3][4] = {    // lie 的偏移量
    {1, 2, 1, 2},
    {0, 1, 0, 1},
    {2, 0, 2, 0}
};

struct State{int x, y, lie;}; // x, y 存坐标位置，lie 存箱子状态 (0, 1, 2)

int n, m;     // 存地图大小
int ex, ey;   // 存终点坐标
char g[N][N]; // 存地图
// dist 存到每个 State 的距离，dist[x][y][lie] 表示从初始状态到 坐标为 (x, y)，状态为 lie 的 State 的距离
int dist[N][N][3];

State q[3 * N * N]; // 广搜的队列。由于每个格上有三种状态，所以要开到 3 * 地图大小
int hh, tt;         // 队尾和队头

int bfs(int x, int y, int lie) // 传入初始坐标和状态
{
    hh = tt = 0;               // 将 hh 和 tt 重置为 0
    *q = (State){x, y, lie};   // {x, y, lie} 入队
    memset(dist, -1, sizeof dist); // 将到所有 State 的距离初始化为 -1
    dist[x][y][lie] = 0;       // 初始的 State 的距离初始化为 0
    while (hh <= tt)           // 开始广搜
    {
        State t = q[hh ++ ];   // 取出对头
        x = t.x, y = t.y, lie = t.lie; // 取出对头的坐标与状态
        if (x == ex && y == ey && !lie) return dist[x][y][lie]; // 如果立着到达终点了，那么返回该距离
        for (int i = 0; i < 4; i ++ )  // 向四个方向扩展
        {
            int nx = x + dx[lie][i];   // 求出向该方向扩展后的 x 坐标
            int ny = y + dy[lie][i];   // 求出 y 坐标
            int nlie = dl[lie][i];     // 求出 lie
            if (nx >= 0 && ny >= 0 && nx < n && ny < m) // 如果该坐标在地图内
            {
                if (g[nx][ny] == '#') continue;                  // 如果该格为禁地，那么跳过，进行下一重循环
                if (!nlie && g[nx][ny] == 'E') continue;         // 如果该状态为立在了易碎地，跳过
                if (nlie == 1 && g[nx + 1][ny] == '#') continue; // 如果该状态为竖着，且靠下的那格是禁地，那么跳过
                if (nlie == 2 && g[nx][ny + 1] == '#') continue; // 如果该状态为横着，且靠右的那个是禁地，那么跳过
                if (!~dist[nx][ny][nlie]) // 如果并非以上情况，且该 State 没有到过，
                {
                    dist[nx][ny][nlie] = dist[x][y][lie] + 1; // 那么记录到该 State 的距离，
                    q[ ++ tt] = (State) {nx, ny, nlie};       // State 入队
                }
            }
        }
    }
    return -1; // 如果无法立着到终点，返回 -1
}

int main()
{
    while (scanf("%d%d", &n, &m), n || m)
    {
        for (int i = 0; i < n; i ++ ) scanf("%s", g[i]);
        int x, y, lie; // 找初始的位置与状态
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < m; j ++ )
                if (g[i][j] == 'X') // 如果该格为起点
                {
                    x = i, y = j, g[i][j] = '.'; // 那么记录该格位置，将该格改为硬地
                    if (g[i + 1][j] == 'X') lie = 1, g[i + 1][j] = '.';      // 如果下面那格是硬地，那么 lie = 1，下面那格也制成 '.'
                    else if (g[i][j + 1] == 'X') lie = 2, g[i][j + 1] = '.'; // 否则如果左边那格硬地，那么 lie = 2，左边那格制成 '.'
                    else    lie = 0; // 否则 lie 制成 0
                }
                else if (g[i][j] == 'O') // 如果该格为终点
                    ex = i, ey = j, g[i][j] = '.'; // 那么记录该格位置，并把该格改为硬地
        int res=bfs(x, y, lie);        // bfs 一遍
        if (~res) printf("%d\n", res); // 如果返回值不为 -1，那么输出返回值
        else    puts("Impossible");    // 否则输出 Impossible
    }
    return 0;
}