nyoj 82 迷宫寻宝（一）

/**
时间限制：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
*/

/**
要点：
一个门必须要找全所有这个门的钥匙才能将其打开，门最多有5扇，在数据输入时统计其对应钥匙的个数，然后从起始点搜索
注意钥匙也是可以到达的地方，
要解决的关键问题：门与钥匙的问题！能否找到对应门的所有钥匙！！
对应的解决方案：在搜索过程中每遇到一个门检测是否已找全其所有对应的钥匙，找全了就直接开门，进入下
一个状态；找不全，由于不确定是否后续可以找到所有的钥匙，需要把该门先存起来（用一个栈）
在搜索过程中每遇到一个钥匙，由于钥匙的地方是可以到达的，直接进入该地点，同时检测是否已经找全了其对应
的全部门的所有钥匙，一旦发现找全了，则说明其对应的所有该类门都可以打开进入了，于是将栈中存储该类的门
全部导入到队列中去。
数据结构 + 算法 = 程序
*/

#include <iostream>
#include <map>
#include <queue>
#include <cstdio>
#include <memory.h>
#include <ctime>
#define S 30
using namespace std;

typedef pair<int,int>point;
queue<point>que;

int N,M,sx,sy;
char maze[S][S];
int vis[S][S],key[5];
const int dirx[4]={-1,1,0,0},diry[4]={0,0,-1,1};
vector<point>door[5];

bool bfs(){
point cur,next;
int acquire[5]={0};
while(que.size()){
cur = que.front();
que.pop();
int cx = cur.first,cy = cur.second;
//cout << "step:" << cx << "," << cy << "value:" << maze[cx][cy] << endl;
//if(maze[cx][cy]=='G') return true;
for(int i=0;i<4;i++){
int nx = cx+dirx[i] , ny = cy+diry[i];
char ch = maze[nx][ny];//ch是下一个能到达的位置的状态
if(nx>=0&&nx<N&&ny>=0&&ny<M&&ch!='X'&&!vis[nx][ny]){//先看能不能走，之前是否走过
if(ch=='.'){
vis[nx][ny] = 1;
que.push(make_pair(nx,ny));
}
else if(ch>='a'&&ch<='e'){//找到对应门的钥匙，判断对应的门能否打开
vis[nx][ny] = 1;
//maze[nx][ny] = '.';
acquire[ch-'a']++;
que.push(make_pair(nx,ny));
//一旦能开，将对应的所有门打开（即导入到队列中去）
while(key[ch-'a']==acquire[ch-'a']&&!door[ch-'a'].empty()){
que.push(door[ch-'a'].back());
door[ch-'a'].pop_back();
}
}
else if(ch>='A'&&ch<='E'){
int t = ch-'A';
//必须要在这儿push而不能在main函数数据输入时push门的坐标，因为后期如果门所有的钥匙都找到了的话并不是
//所有的门都可以开，因为有的门是无法到达的，被墙壁阻隔！！
if(acquire[t]!=key[t]){//开不了门，将门的坐标存入一个栈，看后面能不能开，如果能开就再将其导入队列中（队列中的元素都是可以到达的）
door[t].push_back(make_pair(nx,ny));
vis[nx][ny] = 1;
}
else{//能开门，直接开，并将位置坐标导入到队列中去
vis[nx][ny] = 1;
que.push(make_pair(nx,ny));
}
}
else if(ch=='G') return true;
}
}
}
return false;
}

int main(){
while(scanf("%d %d",&N,&M)&&(N||M)){
getchar();
memset(key,0,sizeof(key));
memset(vis,0,sizeof(vis));
memset(door,0,sizeof(door));
while(que.size()) que.pop();
for(int i=0;i<N;i++){
for(int j=0;j<M;j++){
scanf("%c",&maze[i][j]);
if(maze[i][j]=='S'){
sx = i;
sy = j;
}//key[]事先存好了所有对应的钥匙种类对应数目
else if(maze[i][j]>='a'&&maze[i][j]<='e'){
int t = maze[i][j] - 'a';
key[t]++;
}
}
getchar();
}
vis[sx][sy] = 1;
que.push(make_pair(sx,sy));
if(bfs()) printf("YES\n");
else printf("NO\n");
}
return 0;
}