『Pushing Boxes 双重bfs』

<更新提示>

<第一次更新>

---

<正文>

Pushing Boxes

Description

Imagine you are standing inside a two-dimensional maze composed of square cells which may or may not be filled with rock. You can move north, south, east or west one cell at a step. These moves are called walks. One of the empty cells contains a box which can be moved to an adjacent free cell by standing next to the box and then moving in the direction of the box. Such a move is called a push. The box cannot be moved in any other way than by pushing, which means that if you push it into a corner you can never get it out of the corner again.

One of the empty cells is marked as the target cell. Your job is to bring the box to the target cell by a sequence of walks and pushes. As the box is very heavy, you would like to minimize the number of pushes. Can you write a program that will work out the best such sequence?

想象一下，你站在一个二维的迷宫里，由方形的格子组成，可能有或者没有被岩石充满。你可以在一个格子上向北、南、东或西移动。这些动作叫做步行。 其中一个空格子包含一个盒子，它可以通过站在盒子旁边，然后在盒子的方向上移动，移动到相邻的空格子。这样的动作叫做推。这个盒子不能用任何其他方式来移动，这意味着如果你把它推到角落里，你就再也不能把它从角落里拿出来。

其中一个空格子被标记为目标格子。你的工作是把箱子放在目标格子中，通过一系列的行走和推动。由于箱子很重，你想把推的数量减到最少。你能写出一个程序来找出最好的顺序吗？

Input Format

迷宫描述都包含一个包含两个整数R和C的线段(R,C<=20R,C<=)，表示迷宫的行数和列数。

下面是每个包含C字符的R行。每个字符描述迷宫中的一个单元。一个岩石的格子是由一个'#'表示的，一个空的格子由一个'.'表示。你的起始位置用“S”表示，方框的开始位置由“B”和目标格子按“T”表示。

Output Format

如果不可能把盒子带到目标单元格，打印"Impossible."。

否则，输出一个最小化推送次数的序列。如果有不止一个这样的序列，那么选择一个最小化总移动次数（步行和推送）的序列。如果仍然有不止一个这样的序列，任何一个都是可以接受的。

将序列打印为字符N、S、E、W、n、s、e和w的字符串，其中大写字母代表推，小写字母代表行走，不同字母代表南北、南、东和西的方向。

Sample Input

7 11
###########
#T##......#
#.#.#..####
#....B....#
#.######..#
#.....S...#
###########

Sample Output

eennwwWWWWeeeeeesswwwwwwwnNN

解析

这真是一到毒瘤\(bfs\)，写了两天，然后校内\(OJ\)因为没有\(SPJ\)所以挂了半天，最后老师推了锅，就由我写了\(SPJ\)，真好。

正解应该是双重\(bfs\)。由于题目要求在推箱子次数最小的情况下，人走的步数最小。所以设置状态\((x,y,dir)\)代表箱子在\((x,y)\)位置，人在箱子\(dir\)方向。即人在\((x-dx_{dir},y-dy_{dir})\)的位置。然后对箱子进行\(bfs\)，每一次枚举一个方向\(j\)，代表人从\((x-dx_{dir},y-dy_{dir})\)位置走到\((x-dx_{j},y-dy_{j})\)，然后向\(j\)方向推一下箱子，将箱子推到\((x+dx_j,y+dy_j)\)，即拓展到状态\((x+dx_j,y+dy_j,j)\)。

那么怎么将人从\((x-dx_{dir},y-dy_{dir})\)位置走到\((x-dx_{j},y-dy_{j})\)呢，这又是一个朴素\(bfs\)问题，再箱子\(bfs\)的基础上对人执行一遍\(bfs\)即可。

题目还要求输出方案，只要记录每一个状态是由哪一个状态转移过来的，然后得到最优解后用\(while\)循环倒序遍历得到方案即可。

当然，还会有一些小问题，从人的起点走到箱子旁边，显然还要再写一个\(bfs\)，到箱子旁边后，对于多个起始状态，我们需要对每一个起始状态都执行一遍从头开始的双重\(bfs\)算法，对于每一次执行双重\(bfs\)算法，到达的第一个目标状态就是最优解。

如果还有问题的话，就是再两次箱子移动时，人如何移动的方案并没有记录，那么就要求我们在得到答案是也要再写一个\(bfs\)重新找到人移动的路径，才能得到方案了。也就是说，算上双重\(bfs\)找最短路径，预处理一个\(bfs\)，输出方案一个\(bfs\)，总共需要写\(4\)个\(bfs\)函数。

\(tips:\)本文算法可以达到\(0ms\)解决该问题。

\(Code:\)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
#define mset(name,val) memset(name,val,sizeof name)
#define filein(str) freopen(str".in","r",stdin)
#define fileout(str) freopen(str".out","w",stdout)
const int N=100,M=100;
const int dx[4]={-1,1,0,0},dy[4]={0,0,-1,1};
struct state
{
	int x,y,dir;
	inline void clear(void)
	{
		x=y=dir=0;
	}
};
struct node
{
	int x,y;
	inline void clear(void)
	{
		x=y=0;
	}
};
int CASE,n,m,Map[N][M],cntst,cnted,fcost[10],d[N][M][4];
node man,box,end;
state st[10],ed[10],F[N][M][4];
string prepmove[10],move;
inline bool input(void)
{
	scanf("%d%d",&n,&m);
	if(!n&&!m)return false;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			char c=' ';
			while(isspace(c))c=getchar();
			if(c=='#')Map[i][j]=0;
			if(c=='.')Map[i][j]=1;
			if(c=='S')Map[i][j]=1,man=(node){i,j};
			if(c=='B')Map[i][j]=1,box=(node){i,j};
			if(c=='T')Map[i][j]=1,end=(node){i,j};
		}
	}
	return true;
}
inline bool check(int x,int y)
{
	return x>=1&&y>=1&&x<=n&&y<=m;
}
inline char way(int k)
{
	switch(k)
	{
		case 0:return 'n';
		case 1:return 's';
		case 2:return 'w';
		case 3:return 'e';
	}
}
inline void Prepbfs(void)
{
	for(int i=0;i<4;i++)
	{
		int x=end.x-dx[i],y=end.y-dy[i];
		if(Map[x][y])
			ed[++cnted]=(state){end.x,end.y,i};
	}
	int dis[N][M];node f[N][M];
	mset(dis,-1);
	queue < node > q;
	q.push(man);
	dis[man.x][man.y]=0;f[man.x][man.y]=(node){0,0};
	while(!q.empty())
	{
		node temp=q.front();
		q.pop();
		for(int i=0;i<4;i++)
		{
			int tx=temp.x+dx[i],ty=temp.y+dy[i];
			if(check(tx,ty)&&Map[tx][ty]&&dis[tx][ty]==-1)
			{
				if(tx==box.x&&ty==box.y)
				{
					st[++cntst]=(state){tx,ty,i};
					fcost[cntst]=dis[temp.x][temp.y];
					int x=temp.x,y=temp.y;
					while(f[x][y].x&&f[x][y].y)
					{
						for(int j=0;j<4;j++)
							if(f[x][y].x+dx[j]==x&&f[x][y].y+dy[j]==y)
								prepmove[cntst]+=way(j);
						int Tx=x,Ty=y;
						x=f[Tx][Ty].x;y=f[Tx][Ty].y;
					}
				}
				else
				{
					dis[tx][ty]=dis[temp.x][temp.y]+1;
					f[tx][ty]=(node){temp.x,temp.y};
					q.push((node){tx,ty});
				}
			}
		}
	}
}
inline int Expand(node s,node t,node p)
{
	if(s.x==t.x&&s.y==t.y)return 0;
	int dis[N][M];
	mset(dis,-1);
	dis[s.x][s.y]=0;
	queue < node > q;
	q.push(s);
	while(!q.empty())
	{
		node temp=q.front();
		q.pop();
		for(int i=0;i<4;i++)
		{
			int tx=temp.x+dx[i],ty=temp.y+dy[i];
			if(check(tx,ty)&&Map[tx][ty]&&dis[tx][ty]==-1&&(tx!=p.x||ty!=p.y))
			{
				dis[tx][ty]=dis[temp.x][temp.y]+1;
				if(tx==t.x&&ty==t.y)return dis[tx][ty];
				q.push((node){tx,ty});
			}
		}
	}
	return -1;
}
inline bool Arrive(state p)
{
	for(int i=1;i<=cnted;i++)
		if(ed[i].x==p.x&&ed[i].y==p.y&&ed[i].dir==p.dir)
			return true;
	return false;
}
inline string Reexband(node s,node t,node p)
{
	string res="";
	if(s.x==t.x&&s.y==t.y)return res;
	int dis[N][M];
	node f[N][M];
	mset(dis,-1);
	dis[s.x][s.y]=0;
	f[s.x][s.y]=(node){0,0};
	queue < node > q;
	q.push(s);
	while(!q.empty())
	{
		node temp=q.front();
		q.pop();
		for(int i=0;i<4;i++)
		{
			int tx=temp.x+dx[i],ty=temp.y+dy[i];
			if(check(tx,ty)&&Map[tx][ty]&&dis[tx][ty]==-1&&(tx!=p.x||ty!=p.y))
			{
				dis[tx][ty]=dis[temp.x][temp.y]+1;
				f[tx][ty]=(node){temp.x,temp.y};
				if(tx==t.x&&ty==t.y)
				{
					int x=tx,y=ty;
					while(f[x][y].x&&f[x][y].y)
					{
						for(int j=0;j<4;j++)
							if(f[x][y].x+dx[j]==x&&f[x][y].y+dy[j]==y)
								res+=way(j);
						int Tx=x,Ty=y;
						x=f[Tx][Ty].x;y=f[Tx][Ty].y;
					}
					return res;
				}
				q.push((node){tx,ty});
			}
		}
	}
}
inline void find(int x,int y,int dir)
{
	string temp="";
	while(F[x][y][dir].x&&F[x][y][dir].y)
	{
		for(int i=0;i<4;i++)
		{
			if(F[x][y][dir].x+dx[i]==x&&F[x][y][dir].y+dy[i]==y)
			{
				temp+=(char)(way(i)-'a'+'A');
				int manendx=F[x][y][dir].x - dx[i];
				int manendy=F[x][y][dir].y - dy[i];
				int manstx=F[x][y][dir].x - dx[ F[x][y][dir].dir ];
				int mansty=F[x][y][dir].y - dy[ F[x][y][dir].dir ];
				temp+=Reexband( (node){manstx,mansty} , (node){manendx,manendy} , (node){F[x][y][dir].x,F[x][y][dir].y} );
				break;
			}
		}
		int Tx=x,Ty=y,Tdir=dir;
		x=F[Tx][Ty][Tdir].x;y=F[Tx][Ty][Tdir].y;dir=F[Tx][Ty][Tdir].dir;
	}
	for(int i=1;i<=cntst;i++)
		if(st[i].x==x&&st[i].y==y&&st[i].dir==dir)
			temp+=prepmove[i];
	int cnttemp=0,cntmove=0;
	for(int i=0;i<temp.size();i++)
		if(temp[i]>='A'&&temp[i]<='Z')cnttemp++;
	for(int i=0;i<move.size();i++)
		if(move[i]>='A'&&move[i]<='Z')cntmove++;
	if(move.size()==0||(cnttemp<cntmove)||(cnttemp==cntmove&&temp.size()<move.size()))
		move=temp;
}
inline int Bfs(void)
{
	int res=-1;
	for(int i=1;i<=cntst;i++)
	{
		queue < state > q;
		mset(d,-1);
		mset(F,0);
		q.push(st[i]);
		F[st[i].x][st[i].y][st[i].dir]=(state){0,0,0};
		d[st[i].x][st[i].y][st[i].dir]=fcost[i];
		while(!q.empty())
		{
			state temp=q.front();
			q.pop();
			int x=temp.x,y=temp.y,dir=temp.dir;
			if(Arrive(temp))
			{
				find(x,y,dir);
				res=1;
				break;
			}
			for(int j=0;j<4;j++)
			{
				state t=(state){x+dx[j],y+dy[j],j};
				if(!check(t.x,t.y)||!Map[t.x][t.y]||d[t.x][t.y][t.dir]!=-1||!Map[x-dx[j]][y-dy[j]])continue;
				int spend=Expand( (node){x-dx[dir],y-dy[dir]} , (node){x-dx[j],y-dy[j]} , (node){x,y} );
				if( spend!=-1 )
				{
					F[t.x][t.y][t.dir]=(state){x,y,dir};
					d[t.x][t.y][t.dir]=d[x][y][dir]+spend+1;
					q.push(t);
				}
			}
		}
	}
	return res;
}
int main(void)
{
	filein("test");
	fileout("test");
	input();
	Prepbfs();
	int ans=Bfs();
	if(ans==-1)printf("Impossible.\n");
	else
	{
		for(int i=move.size()-1;i>=0;i--)
			printf("%c",move[i]);
		puts("\n");
	}
	return 0;
}

---

<后记>