POJ1475 推箱子（双重 bfs）

原题链接：http://poj.org/problem?id=1475
代码基本功还是欠缺的很啊，这道搜索题调了我两天，我想有必要记录一下。
如果只记录 \((xB, yB, xM, yM)\) 这个四元组进行 \(bfs\) 的话，只能保证总体步数在队列中的单调性，而本题要求先保证箱子的移动步数最少的情况下，人的移动步数最少。因此这么 \(bfs\) 是错误的，在利用这个四元组作为状态的前提下，如果非要用 \(bfs\) 解决这题的话，只能仿照 \(spfa\) 的做法了，时间复杂度为 \(O(玄学)\)，会超时。
此时，我们需要使用双重 \(bfs\)算法来解决本题。
观察到，人推箱子时，人必定在箱子的四个方向上，因此可以将这个状态压缩为 \((x, y, dir)\) 表示箱子位于 \((x, y)\)，人在箱子的 \(dir\) 方向上。
这么做有什么好处呢？根据 \(bfs\) 的性质，我们已经能够保证箱子的移动步数作为第一关键字，且是单调递增的了。
接下来，我们考虑状态的扩展，假设 \((x, y, dir)\) 扩展到了 \((x + dirx[k], y + diry[k], k)\)，那么人走的步数就是不经过 \((x, y)\) 从 \((x-dirx[dir], diry[dir])\) 走到 \((x-dirx[k], y-diry[k])\) 的最少步数，这不是另一个 \(bfs\) 吗？于是，我们可以使用 \(bfs\) 嵌套 \(bfs\)，即双重 \(bfs\) 来解决本题。
现在回头来分析这么做为什么能时刻保证队列中元素的单调性，只要注意到代码中的一个细节，这个性质就是显然的：我们对于一个新状态，就直接更新箱子的移动步数和人的移动步数，并加入队列中；如果这个状态之前被访问过，但是此时箱子的移动次数却相等，那我们对两者的人的移动次数取 \(\min\) 即可。注意到 \(bfs\) 队列的层次单调性蕴含着其至多包含两层的状态（两段性），因此如果此时箱子的移动次数相等，说明第一层还没取完，且这个新状态位于第二层，就更不可能被取出过，因此不会影响队列的顺序，从而保证了单调性。
由于还要输出具体的走法，我们需要使用 \(last\) 数组来记录一下。

talk is cheap, show me your code!

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 25;
int n, m;
char s[maxn][maxn];
int fMan[maxn][maxn][4], fBox[maxn][maxn][4];
int dirx[4] = {-1, 1, 0, 0}, diry[4] = {0, 0, -1, 1};

int lastMan[maxn][maxn];
struct node { int x, y, dir; } lastBox[maxn][maxn][4];

inline bool valid(int x, int y) { return 1 <= x && x <= n && 1 <= y && y <= m && s[x][y] != '#'; }

int dis[maxn][maxn];
int bfsMan(int sx, int sy, int tx, int ty, int banx, int bany) {
	memset(dis, -1, sizeof(dis));
	queue<node> queM;
	dis[sx][sy] = 0; queM.push((node){sx, sy});
	while (!queM.empty()) {
		node cur = queM.front(); queM.pop();
		if (cur.x == tx && cur.y == ty) return dis[cur.x][cur.y];
		for (int k = 0; k < 4; k++) {
			int x = cur.x + dirx[k], y = cur.y + diry[k];
			if (!valid(x, y)) continue;
			if (dis[x][y] == -1 && (x != banx || y != bany)) {
				dis[x][y] = dis[cur.x][cur.y] + 1;
				lastMan[x][y] = k;
				queM.push((node){x, y});
			}
		}
	}
	return -1; // impossible
}

inline int getDir(int dx, int dy) {
	if (dx == -1) return 0;
	else if (dx == 1) return 1;
	else if (dy == -1) return 2;
	else return 3;
}

char dir2strU[4] = {'N', 'S', 'W', 'E'}, dir2strL[4] = {'n', 's', 'w', 'e'};
void bfsBox() {
	memset(fMan, -1, sizeof(fMan));
	memset(fBox, -1, sizeof(fBox));
	queue<node> queB;
	int sx = 0, sy = 0, manx = 0, many = 0, usedDir[4] = {0, 0, 0, 0};
	for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) if (s[i][j] == 'S') manx = i, many = j;
	for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) if (s[i][j] == 'B') {
		sx = i; sy = j;
		for (int k = 0; k < 4; k++) {
			int x = i - dirx[k], y = j - diry[k];
			if (!valid(x, y)) continue;
			int moveMan = bfsMan(manx, many, x, y, sx, sy);
			if (moveMan < 0) continue;
			usedDir[k] = 1;
			fMan[i][j][k] = moveMan; fBox[i][j][k] = 0;
			queB.push((node){i, j, k});
		}
	}
	while (!queB.empty()) {
		node cur = queB.front(); queB.pop();
		for (int k = 0; k < 4; k++) {
			int x = cur.x + dirx[k], y = cur.y + diry[k];
			if (!valid(x, y)) continue;
			int moveMan = bfsMan(cur.x - dirx[cur.dir], cur.y - diry[cur.dir], cur.x - dirx[k], cur.y - diry[k], cur.x, cur.y);
			if (moveMan < 0) continue;
                        // 注意。下面几行维护了单调性
			if (fBox[x][y][k] == -1) {
				fBox[x][y][k] = fBox[cur.x][cur.y][cur.dir] + 1;
				fMan[x][y][k] = fMan[cur.x][cur.y][cur.dir] + moveMan;
				lastBox[x][y][k] = cur;
				queB.push((node){x, y, k});
			} else if (fBox[x][y][k] == fBox[cur.x][cur.y][cur.dir] + 1) {
				if (fMan[cur.x][cur.y][cur.dir] + moveMan < fMan[x][y][k]) {
					fMan[x][y][k] = fMan[cur.x][cur.y][cur.dir] + moveMan;
					lastBox[x][y][k] = cur;
				}
			}
		}
	}
	// construct the answer sequence
	int tx = 0, ty = 0, pos = -1;
	for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) if (s[i][j] == 'T') tx = i, ty = j;
	for (int k = 0; k < 4; k++) if (fBox[tx][ty][k] >= 0) pos = k;
	if (pos < 0) { puts("Impossible."); return ; }
	for (int k = 0; k < 4; k++) if (fBox[tx][ty][k] >= 0)
		if (fBox[tx][ty][k] < fBox[tx][ty][pos]) pos = k;
		else if (fBox[tx][ty][k] == fBox[tx][ty][pos] && fMan[tx][ty][k] < fMan[tx][ty][pos]) pos = k;
	node cur = (node){tx, ty, pos}; string ans;
        // 注意，这里要用 usedDir 来记录是否是起点，因为光判 (x, y) 不一定说明是起点
	while (cur.x != sx || cur.y != sy || !usedDir[cur.dir]) {
		int x = lastBox[cur.x][cur.y][cur.dir].x, y = lastBox[cur.x][cur.y][cur.dir].y;
		int dir = lastBox[cur.x][cur.y][cur.dir].dir, k = getDir(cur.x - x, cur.y - y);
		ans.push_back(dir2strU[k]);
		bfsMan(x - dirx[dir], y - diry[dir], x - dirx[k], y - diry[k], x, y);
		int tmpx = x - dirx[k], tmpy = y - diry[k];
		while (tmpx != x - dirx[dir] || tmpy != y - diry[dir]) {
			int tmpdir = lastMan[tmpx][tmpy];
			ans.push_back(dir2strL[tmpdir]);
			tmpx -= dirx[tmpdir]; tmpy -= diry[tmpdir];
		}
		cur = lastBox[cur.x][cur.y][cur.dir];
	}
	bfsMan(manx, many, cur.x - dirx[cur.dir], cur.y - diry[cur.dir], sx, sy);
	int tmpx = cur.x - dirx[cur.dir], tmpy = cur.y - diry[cur.dir];
	while (tmpx != manx || tmpy != many) {
		int tmpdir = lastMan[tmpx][tmpy];
		ans.push_back(dir2strL[tmpdir]);
		tmpx -= dirx[tmpdir]; tmpy -= diry[tmpdir];
	}
	reverse(ans.begin(), ans.end());
	printf("%s\n", ans.c_str());
}

int main() {
	for (int tc = 1;; tc++) {
		scanf("%d%d", &n, &m);
		if (!n && !m) break;
		for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
		printf("Maze #%d\n", tc);
		bfsBox(); puts("");	
	}
	return 0;
}