【洛谷 P1141】01迷宫 题解（广度优先搜索+记忆化搜索+位集合+队列）

01迷宫

题目描述

有一个仅由数字 $0$ 与 $1$ 组成的 $n\times n$ 格迷宫。若你位于一格 $0$ 上，那么你可以移动到相邻 $4$ 格中的某一格 $1$ 上，同样若你位于一格 $1$ 上，那么你可以移动到相邻 $4$ 格中的某一格 $0$ 上。

你的任务是：对于给定的迷宫，询问从某一格开始能移动到多少个格子（包含自身）。

输入格式

第一行为两个正整数 $n,m$。

下面 $n$ 行，每行 $n$ 个字符，字符只可能是 $0$ 或者 $1$，字符之间没有空格。

接下来 $m$ 行，每行两个用空格分隔的正整数 $i,j$，对应了迷宫中第 $i$ 行第 $j$ 列的一个格子，询问从这一格开始能移动到多少格。

输出格式

$m$ 行，对于每个询问输出相应答案。

样例 #1

样例输入 #1

2 2
01
10
1 1
2 2

样例输出 #1

4
4

提示

对于样例，所有格子互相可达。

• 对于 $20\%$ 的数据，$n\le 10$；
• 对于 $40\%$ 的数据，$n\le 50$；
• 对于 $50\%$ 的数据，$m\le 5$；
• 对于 $60\%$ 的数据，$n,m\le 100$；
• 对于 $100\%$ 的数据，$1\le n\le 1000$，$1\le m\le 100000$。

---

思路

首先定义一些常量和变量，包括迷宫的大小 N，用于存储迷宫的二维数组 ch 和结果的二维数组 ans。还定义一个队列 q1 用于广度优先搜索（BFS），和一个二维的位集 vis 用于标记已访问的点。同时定义一个结构体 P 用于表示点的坐标，和一个数组 dir 用于表示四个方向。

在 bfs 函数中，首先调用 init 函数初始化 vis 和 q1。然后将起始点加入队列 q1，并在队列不为空的情况下，取出队首元素，如果这个元素已经被访问过，或者 ans 数组中已经有这个点的结果，就跳过这个点。否则，将这个点标记为已访问，并将可以到达的点加入队列。最后返回可以到达的点的数量。

在 main 函数中，首先读取迷宫的大小 n 和询问的数量 m，然后读取迷宫，并将 ans 数组初始化为 -1。接着，对于每个询问，如果 ans 数组中还没有这个点的结果，就调用 bfs 函数计算结果，并将结果存入 ans 数组，然后输出结果。

注意

记忆化搜索是一种优化技术，可以将已经计算过的结果存储起来，避免重复计算。需要使用记忆化搜索优化，否则部分测试点报超时。

---

AC代码

#include <algorithm>
#include <bitset>
#include <cstring>
#include <iostream>
#include <queue>
#define AUTHOR "HEX9CF"
using namespace std;
using ll = long long;

const int N = 1e3 + 7;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;

struct P {
	ll x, y;
};
const P dir[4] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

ll n, m;
char ch[N][N];
ll ans[N][N];
queue<P> q1;
bitset<N> vis[N];

void init() {
	for (int i = 1; i <= n; i++) {
		vis[i].reset();
	}
	while (q1.size()) {
		q1.pop();
	}
}

ll bfs(ll x, ll y) {
	init();
	ll cnt = 0;
	q1.push({x, y});
	while (q1.size()) {
		auto f = q1.front();
		q1.pop();
		if (vis[f.x][f.y]) {
			continue;
		}
		if(~ans[f.x][f.y]) {
			return ans[f.x][f.y];
		}
		vis[f.x][f.y] = 1;
		cnt++;
		for (int i = 0; i < 4; i++) {
			ll xx = f.x + dir[i].x;
			ll yy = f.y + dir[i].y;
			if (xx < 1 || xx > n || yy < 1 || yy > n || ch[xx][yy] == ch[f.x][f.y]) {
				continue;
			}
			q1.push({xx, yy});
		}
	}
	return cnt;
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	
	memset(ans, -1, sizeof(ans));

	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			cin >> ch[i][j];
		}
	}
	for (int i = 1; i <= m; i++) {
		ll x, y;
		cin >> x >> y;
		if(!~ans[x][y]) {
			init();
			ans[x][y] = bfs(x, y);
		}
		cout << ans[x][y] << "\n";
	}
	return 0;
}