洛谷 P1141 01迷宫 #图的遍历与连通性 BFS#

版权声明：while (!success) try(); https://blog.csdn.net/qq_35850147/article/details/89345082

题目描述

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

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

输入输出格式

输入格式：

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

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

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

输出格式：

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

输入输出样例

输入样例#1： 复制

2 2
01
10
1 1
2 2

输出样例#1： 复制

4
4

说明

所有格子互相可达。

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

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

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

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

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

题解

#include <bits/stdc++.h>

using namespace std;

const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
int n, m;
int g[1001][1001];
int v[1001][1001];
bool vis[1001][1001];
struct cor
{
    int x, y;
};

bool is_inside(int x, int y)
{
    return x >= 1 && x <= n && y >= 1 && y <= n ? true : false;
}

int BFS(int x, int y)
{
    int cnt = 0;
    queue<cor> q;
    vector<cor> vec;
    q.push(cor{x, y});
    vis[x][y] = true;
    while (!q.empty())
    {
        cor c = q.front();
        int a = c.x, b = c.y;
        q.pop();
        cnt++;
        for (int i = 0; i < 4; i++)
        {
            if (is_inside(a + dx[i], b + dy[i]) && g[a + dx[i]][b + dy[i]] != g[a][b] && !vis[a + dx[i]][b + dy[i]])
            {
                q.push(cor{a + dx[i], b + dy[i]});
                vis[a + dx[i]][b + dy[i]] = true;
                vec.push_back(cor{a + dx[i], b + dy[i]});
            }
        }
    }
    for (int i = 0; i < (int)vec.size(); i++)
    {
        cor c = vec[i];
        v[c.x][c.y] = cnt;
    }
    return v[x][y] = cnt;
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
    {
        char s[n + 1];
        scanf("%s", s);
        for (int j = 1; j <= n; j++)
            g[i][j] = s[j - 1] - '0';
    }
    for (int i = 0; i < m; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("%d\n", v[a][b] ? v[a][b] : BFS(a, b));
    }
    return 0;
}