P1141 01迷宫（BFS+简单连通块优化解析）

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$。

思路分析：
这个题看一下就知道要用dfs或者bfs，但是直接爆搜的话会肯定会超时最后只能过70分，所以我们要想一个方法来优化，首先这个题是需要记录每一个开始走可以走到的最大的步骤，设想一下啊，如果有一条这样的路径存在：a–>b–>c–>d，那么无论a还是b还是c还是d，他们可以走到的最远的路径都是这个4，所以我们不必要每一个点都开始搜，只要在满足的一条路上全都标记一下，类似于并查集，但是这里根本不用那么麻烦，直接用一个数组来标记即可，直接上代码，代码有详解

#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
#include<queue>
#define x first
#define y second
const int N = 1010;
using namespace std;
typedef pair<int, int>PII;
int n, m,a,b;
char g[N][N];
bool st[N][N];
int vis[N][N];//记录联通区间
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };//方向
int res,k=1;
int ans[20000005];//存档答案
queue<PII>q;
void bfs(int a,int b)
{
    
    q.push({ a,b });
    while (q.size())
    {
        auto t = q.front();
        q.pop();
        for (int i = 0; i < 4; i++){
            int xx = t.x+ dx[i];
            int yy = t.y + dy[i];
            if (xx >= 1 && yy >= 1 && xx <= n && yy <= n && g[t.x][t.y] != g[xx][yy] && !vis[xx][yy])//判断合法
            {
                vis[xx][yy] = k;
                //起到标记作用
                q.push({ xx,yy });
                res++;//答案数加一
            }
        }
    }
}
int main()
{
    cin >> n >> m;

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            cin >> g[i][j];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) {
            if (!vis[i][j])//没搜过就开搜
            {
                res = 1;//重置点数为1，因为包含这个点本身
                vis[i][j] = k;//标记
                bfs(i, j);
                ans[k] =res;
                k++;
            }


        }
    while (m--)
    {
        cin >> a >> b;
        cout << ans[vis[a][b]] << endl;
    }  
    return 0;
}