NYOJ 82 迷宫寻宝（一） (BFS)

迷宫寻宝（一）

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 4

描述

一个叫ACM的寻宝者找到了一个藏宝图，它根据藏宝图找到了一个迷宫，这是一个很特别的迷宫，迷宫里有N个编过号的门（N<=5)，它们分别被编号为A,B,C,D,E.为了找到宝藏，ACM必须打开门，但是，开门之前必须在迷宫里找到这个打开这个门所需的所有钥匙（每个门都至少有一把钥匙），例如：现在A门有三把钥匙，ACM就必须找全三把钥匙才能打开A门。现在请你编写一个程序来告诉ACM，他能不能顺利的得到宝藏。

 

输入

输入可能会有多组测试数据（不超过10组）。
每组测试数据的第一行包含了两个整数M,N(1<N,M<20)，分别代表了迷宫的行和列。接下来的M每行有N个字符，描述了迷宫的布局。其中每个字符的含义如下：
.表示可以走的路
S:表示ACM的出发点
G表示宝藏的位置
X表示这里有墙，ACM无法进入或者穿过。
A,B,C,D,E表示这里是门，a,b,c,d,e表示对应大写字母的门上的钥匙。
注意ACM只能在迷宫里向上下左右四个方向移动。

最后，输入0 0表示输入结束。

输出

每行输出一个YES表示ACM能找到宝藏，输出NO表示ACM找不到宝藏。

样例输入

4 4 
S.X. 
a.X. 
..XG 
.... 
3 4 
S.Xa 
.aXB 
b.AG 
0 0

样例输出

YES 
NO

一开始普通的BFS模版做的话，会出现问题

比如这组数据

5 5
SXaXG
.X.X.
.X.X.
.X.XA
.....

就比如这组数据， 因为按题意来的话  寻宝者在（0，2）的位置找到钥匙后，就可以回去打开A的门，

但是按普通BFS来说的话，是不能再往回走的，我想了两种思路，一种是多次BFS，一种是储存好门的节点，找到钥匙后，再将门的节点重新入队

我这里采用了第二种思路

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
using namespace std;
int n, m, vis[25][25], key[5];;//行列, 标记数组 
int a[4] = {0, 1, 0, -1}, b[4] = {1, 0, -1, 0};
char map[25][25];
struct node {
  int x, y;
  int temp[5]; //五把钥匙的状态
  int flag;
};
int bfs(node s, node e) {
  int k;
  for(int i = 0; i < 5; i++)//初始化每把钥匙为0 
    s.temp[i] = 0;
  queue<node> q;//定义一个队列
  node t;//临时变量 
  node f[5];
  memset(vis, 0, sizeof(vis));
  vis[s.x][s.y] = 1;
  q.push(s);//起始位置入队 
  while(!q.empty()) {
    t = q.front();
    q.pop();
    if(t.x == e.x && t.y == e.y) return 1;
    for(int i = 0; i < 4; i++) {
      s.x = t.x + a[i];
      s.y = t.y + b[i];
      if(s.x >= 0 && s.x < n && s.y >= 0 && s.y < m && map[s.x][s.y] != 'X' && vis[s.x][s.y] == 0) {
        if (map[s.x][s.y] == '.' || map[s.x][s.y] == 'G' ) {
          q.push(s); 
          vis[s.x][s.y] = 1;
        } 
        else if(map[s.x][s.y] >= 'a' && map[s.x][s.y] <= 'e') {
          k = map[s.x][s.y]-'a';
          s.temp[k]++;//储存钥匙
          q.push(s);
          vis[s.x][s.y] = 1;
          if(s.temp[k] == key[k] && f[k].flag == 1) {//找到钥匙了，并且曾经到达过那个门 
            q.push(f[k]);
            vis[f[k].x][f[k].y] = 1;
          }
        } 
        else if (map[s.x][s.y] >= 'A' && map[s.x][s.y] <= 'E') {
          k = map[s.x][s.y]-'A';
          if(s.temp[k] == key[k]) {
            q.push(s);
            vis[s.x][s.y] = 1;
          } else {//钥匙不够先保存好这个节点，如果后面能找到钥匙就借助这个临时节点入队 
            f[k] = s;
            f[k].flag = 1;//标记一下 , 证明我曾经来过这里 
          }
        } 
      }
    }
  }
  return 0;
}
int main() {
  while(scanf("%d%d", &n, &m) , n || m) {
    int sx, sy, ex, ey;//起始位置和宝藏位置 
    memset(key, 0, sizeof(key));
    for(int i = 0; i < n; i++)
      for(int j = 0; j < m; j++) {
        cin >> map[i][j];
        if(map[i][j] == 'S') {
          sx = i;
          sy = j;
        }
        else if(map[i][j] == 'G') {
          ex = i;
          ey = j;
        } else if(map[i][j] >= 'a' && map[i][j] <= 'e') {
          key[map[i][j]-'a']++;//开门所需要的钥匙 
        }
      }
    node s, e;
    s.x = sx; s.y = sy;
    e.x = ex; e.y = ey;
    if(bfs(s, e)) printf("YES\n");
    else printf("NO\n");
  }
} 

测试数据
5 5
SXaXG
.X.X.
.X.X.
.X.XA
.....

5 5
aE..S
bXX.c
XX.CX
GBA.B
XXe.e

5 5
a...a
XX.XX
bXSXG
.XAXB
.....

5 5
.X.XG
Sa..A
.b.Xc
XX..B
bC...

5 5
.X.XG
Sb..B
.b.Xc
XX..B
bC...

1 10
S.aAbBcC.G

输出结果应该是：YES YES YES YES NO YES