1101. 献给阿尔吉侬的花束

阿尔吉侬是一只聪明又慵懒的小白鼠，它最擅长的就是走各种各样的迷宫。

今天它要挑战一个非常大的迷宫，研究员们为了鼓励阿尔吉侬尽快到达终点，就在终点放了一块阿尔吉侬最喜欢的奶酪。

现在研究员们想知道，如果阿尔吉侬足够聪明，它最少需要多少时间就能吃到奶酪。

迷宫用一个 R×CR×C 的字符矩阵来表示。

字符 S 表示阿尔吉侬所在的位置，字符 E 表示奶酪所在的位置，字符 # 表示墙壁，字符 . 表示可以通行。

阿尔吉侬在 1 个单位时间内可以从当前的位置走到它上下左右四个方向上的任意一个位置，但不能走出地图边界。

输入格式

第一行是一个正整数 TT，表示一共有 TT 组数据。

每一组数据的第一行包含了两个用空格分开的正整数 RR 和 CC，表示地图是一个 R×CR×C 的矩阵。

接下来的 RR 行描述了地图的具体内容，每一行包含了 CC 个字符。字符含义如题目描述中所述。保证有且仅有一个 S 和 E。

输出格式

对于每一组数据，输出阿尔吉侬吃到奶酪的最少单位时间。

若阿尔吉侬无法吃到奶酪，则输出“oop!”（只输出引号里面的内容，不输出引号）。

每组数据的输出结果占一行。

数据范围

1<T≤101<T≤10,
2≤R,C≤2002≤R,C≤200

输入样例：

3
3 4
.S..
###.
..E.
3 4
.S..
.E..
....
3 4
.S..
####
..E.

输出样例：

5
1
oop!

#include <bits/stdc++.h>
using namespace std;
//const int N = 210;
int t, r, c;
string a[210];
typedef pair<int, int> PII;
#define x first
#define y second

int f[210][210];

int bfs(PII start, PII end){
    memset(f, -1, sizeof f);
    queue<PII> p;
    p.push({start.x, start.y});
    f[start.x][start.y] = 0;

    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    while(p.size()){
        PII dd = p.front();//
        p.pop();

        for(int i = 0; i < 4; i ++){
            int xx = dx[i] + dd.x, yy = dy[i] + dd.y;
            if(xx >= r || xx < 0 || yy >= c || yy < 0) continue;
            if(f[xx][yy] != -1) continue;
            if(a[xx][yy] == '#') continue;

            f[xx][yy] = f[dd.x][dd.y] + 1;
            //cout << f[xx][yy] << endl;

            if(make_pair(xx, yy) == end) return f[xx][yy];
            p.push({xx, yy});  //p.push(f[xx][yy]);
        }
    }
    return -1;

}
int main(){
    cin >> t;
    while(t --){
        cin >> r >> c;
        for(int i = 0; i < r; i ++) cin >> a[i];


        PII start, end;
        for(int i = 0; i < r; i ++){
            for(int j = 0; j < c; j ++){
                if(a[i][j] == 'S') start = {i, j};//记住这个赋值方式
                if(a[i][j] == 'E') end = {i, j};
            }
        }

        if(bfs(start, end) == -1) cout << "oop!" << endl;
        else {
            int ans = bfs(start, end);
            cout << ans << endl;
        }
    }
    return 0;
}

//bfs可以搜环，因为有判重数组
//bfs可以找最短路径，但是dfs不行
//bfs不容易出错，但是dfs找错就比较麻烦了
//pair就加上那三行代码--“定义三兄弟”
//不能直接比较pair，要转化成make_pair(x, y)返回成一个pair值
/*BFS是一种借助队列来存储的过程，分层查找，优先考虑距离出发点近的点。
无论是在邻接表还是邻接矩阵中存储，都需要借助一个辅助队列，N个顶点均需入队，
最坏的情况下，空间复杂度为O(N)。
*/
//bfs就是越来越靠近答案，然后一层一层拨开，所以当然是最近的最早被拨开

//当我把memset(f, -1, sizeof f) 放在主函数的时候，返回值永远都是-1， 只有把他放在子函数里面时，f数组的值才会改变，为什么？