题目链接：https://www.luogu.org/problem/P1141

题目描述

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

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

输入格式

第11行为两个正整数n,mn,m。

下面nn行，每行nn个字符，字符只可能是00或者11，字符之间没有空格。

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

输出格式

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

输入输出样例

输入 #1复制

2 2
01
10
1 1
2 2

输出 #1复制

4
4

说明/提示

所有格子互相可达。

对于20\%20%的数据，n≤10n≤10；

对于40\%40%的数据，n≤50n≤50；

对于50\%50%的数据，m≤5m≤5；

对于60\%60%的数据，n≤100,m≤100n≤100,m≤100；

对于100\%100%的数据，n≤1000,m≤100000n≤1000,m≤100000。

---

题解

先介绍采用裸的BFS，当然不能满分。再介绍如何优化得到满分。

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <string.h>

using namespace std;

struct Node
{
    int x, y;
};
Node q[1000005]; 

const int MAXN = 1005;
int n, m, a, b, c, d, front, last, step; 
int pos[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};
char abc[MAXN][MAXN]; // 存储输入的矩阵信息 
bool vis[MAXN][MAXN]; // 是否已经遍历过该点 


void bfs()
{
    Node now;
    now.x = a;
    now.y = b;
    vis[a][b] = 1;
    
    front = last = 0;
    q[last] = now;
    last++;
    while(front < last)
    {
        now = q[front++];
        for(int i = 0; i < 4; i++)
        {
            int nx = now.x + pos[i][0]; 
            int ny = now.y + pos[i][1]; 
            if(nx <= n && nx > 0 && ny <= n && ny > 0 
                && vis[nx][ny] == false 
                && abc[now.x][now.y] != abc[nx][ny]) 
            {
                vis[nx][ny] = true;
                q[last].x = nx;
                q[last].y = ny;
                step++;
                last++;
            }
        } 
    }
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            cin >> abc[i][j];
        }
    }
    for(int i = 1; i <= m; i++)
    {
        cin >> a >> b;
        step = 1;
        bfs();
        cout << step << endl;
        memset(vis, 0, sizeof(vis));
    }
    return 0;
}

裸的BFS并没有什么技巧，只是注意q队列不要太小，太小会导致WA。这个代码会有3个测试点TLE。

 之所以会出现TLE，主要是有很多次询问，每次询问都做了一次BFS，要优化代码就要减少BFS的次数。注意到这样一个事实：如果迷宫中存在连通块，则连通块中各格子到其他格子的个数是相同的。而求连通块本身就是利用BFS实现的。下面就是利用连通块进行优化的代码。

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <string.h>

using namespace std;

struct Node
{
    int x, y;
};
Node q[1000005];
int cnt[1000005];

const int MAXN = 1005;
int n, m, a, b, c, d, front, last, step, num; 
int pos[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};
char abc[MAXN][MAXN]; // 存储输入的矩阵信息 
bool vis[MAXN][MAXN]; // 是否已经遍历过该点
int map[MAXN][MAXN]; // 用于对连通块染色 


void bfs()
{
    Node now, next;
    now.x = a;
    now.y = b;
    map[a][b] = num;
    vis[a][b] = 1;
    step = 1;
    
    front = last = 0;
    q[last] = now;
    last++;
    while(front < last)
    {
        now = q[front++];
        for(int i = 0; i < 4; i++)
        {
            int nx = now.x + pos[i][0]; 
            int ny = now.y + pos[i][1]; 
            if(nx <= n && nx > 0 && ny <= n && ny > 0 
                && vis[nx][ny] == false 
                && abc[now.x][now.y] != abc[nx][ny]) 
            {
                vis[nx][ny] = true;
                q[last].x = nx;
                q[last].y = ny;
                map[nx][ny] = num;
                step++;
                last++;
            }
        } 
    }
    cnt[num] = step;
    num++;