SHU1923 穿墙术（三维BFS)

Description

最近Bob参加了集训，学会了许多新技能，其中一个技能就是神奇的穿墙术。

Bob到处炫耀他的技能，比如用这个技能使得他能够更快地走迷宫。

但是每轮都有使用次数的限制，而且每次他只能穿过一层墙壁（也就是，每经过一次墙壁后，下一步必须走到空地上）。

在迷宫中Bob每次只能选择往上下左右四个方向走一格。

Input

第一行是一个整数T(T<=20)，表示数据组数。

接下来有T组数据，每组数据的第一行是三个整数N,M,K，

分别表示表示迷宫的长宽和Bob最多可以使用技能的次数。

接着是N行M列的迷宫。(2<=N,M<=20, 0<=K<=10)

其中’S’表示起点，’T’表示终点，’x’表示墙，’.’表示空地。

Output

对于每组输入，输出一个整数表示Bob最少花费的时间。（即走过的格数，包括穿墙）

如果不能到达终点，则输出-1。

Sample Input

2

3 3 1

S..

xxx

..T

3 4 2

Sxx.

.xxT

x...

Sample Output

4

6

这次总算没有折腾一晚上了，主要的坑点就是vis数组里应该加一个已经使用穿墙术次数的状态。

代码如下：

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
struct node
{
int x,y;
int t;
int time;
int digest;
};
node S;
char map[25][25];
int vis[15][25][25];
int m,n,k;
int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int check(int digest,int i,int j)
{
if(map[i][j]==0||vis[digest][i][j]==1)
return 0;
return 1;
}
int bfs()
{
queue<node> q;
q.push(S);
vis[S.digest][S.x][S.y]=1;
while(!q.empty())
{
node now=q.front();
q.pop();
if(map[now.x][now.y]=='T'&&now.digest<=k)
return now.time;
for(int i=0;i<4;i++)
{
node next;
next.x=now.x+dir[i][0];
next.y=now.y+dir[i][1];
next.time=now.time+1;
next.digest=now.digest;
if(!check(next.digest,next.x,next.y))
continue;
if(map[next.x][next.y]=='x')
{
if(map[now.x][now.y]=='x')
continue;
else
{
if(next.digest>=k)
continue;
next.digest++;
}
}
vis[next.digest][next.x][next.y]=1;
q.push(next);
}
}
return -1;
}
int main(void)
{
int t,i,j;
cin>>t;
while(t--)
{
memset(map,0,sizeof(map));
memset(vis,0,sizeof(vis));
cin>>n>>m>>k;
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
{
cin>>map[i][j];
if(map[i][j]=='S')
{
S.x=i;
S.y=j;
S.time=0;
S.digest=0;
}
}
int ans=bfs();
cout<<ans<<endl;
}
}