洛谷P1141 01迷宫 解题报告

原题请见洛谷（https://www.luogu.org/problem/show?pid=1141#sub）
题目描述

有一个仅由数字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。
题目中数据范围是1000，单纯的搜索绝对超时而且最朴素的算法在100000次询问每次都搜索一遍必然超时下面我们打一份最朴素的广搜算法

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
int _map[1001][1001];
bool flag[1001][1001];
struct mg{
    int x,y;
}q[1000001];
int main()
{
    int sx,sy,i,j,n,m,l,nx,ny,k,f,r,sum;
    int dx[4]={0,0,-1,1};
    int dy[4]={1,-1,0,0};
    char ch;
    scanf("%d %d",&n,&m);
    for(i=1;i<=n;i++){
        for(j=1;j<=n;j++){
            cin>>ch;
            if(ch=='1'){
                _map[i][j]=1;
            }
            else{
                _map[i][j]=0;
            } 
        }
    }
    for(l=1;l<=m;l++){
        scanf("%d%d",&sx,&sy);
        sum=1;
        f=1;
        r=1;
        q[f].x=sx;
        q[f].y=sy;
        memset(flag,true,sizeof(flag));
        flag[sx][sy]=false;
        while(f<=r){
            for(k=0;k<4;k++){
                nx=q[f].x+dx[k];
                ny=q[f].y+dy[k];
                if(flag[nx][ny]&&nx>=1&&nx<=n&&ny>=1&&ny<=n&&((_map[nx][ny]==0&&_map[q[f].x][q[f].y]==1)||(_map[nx][ny]==1&&_map[q[f].x][q[f].y]==0))){
                    r++;
                    sum++;
                    flag[nx][ny]=false;
                    q[r].x=nx;
                    q[r].y=ny;
                }
            }
            f++;
        }
        printf("%d\n",sum);
    }
    return 0;
}

之后说一下其中的意义maps代表我们输入的地图，flag标记这个地方我们是否走过之后需要注意的是在搜索的过程中保证当前的x，y都在[1,n]这个闭区间内是为了防止数组越界其实这里为了更省空间可以把这里的maps数组直接改成bool数组，但是由于数据量不是很大128MB的空间应该不会崩所以这么优化有点鸡肋

#include<iostream>
#include<cstdio>
using namespace std;
const int N=1010;
const int MQ=N*N;

int n,m; 
bool maze[N][N];//迷宫描述 
int block[N][N];//所属的块 
int ans[N*N];//块的大小 
int tag=1;//块的计数 

struct Dot{
    int x,y;
}que[MQ];
int head,tail,qlen;
inline void ins(Dot a){
    que[tail++]=a;
    tail%=MQ,qlen++; 
}
inline Dot del(){
    Dot ret=que[head++];
    head%=MQ,qlen--;
    return ret;
}//队列 

int test[][2]={{0,-1},{0,1},{1,0},{-1,0}};
void bfs(int x,int y){
    Dot a;
    a.x=x,a.y=y;
    ins(a);
    while(qlen){
        a=del();
        ans[tag]++;//增加块的大小 
        int nx,ny;
        for(int i=0;i<4;i++){
            nx=a.x+test[i][0],ny=a.y+test[i][1];
            if(nx>=0&&nx<n&&ny>=0&&ny<n&&!block[nx][ny]&&maze[nx][ny]==!maze[a.x][a.y]){//这里块的描述也起到一个标记数组的作用 
                block[nx][ny]=tag;
                Dot b=a;
                b.x=nx;
                b.y=ny;
                ins(b);
            }
        }
    }
}

int main(){
    cin>>n>>m;
    char ch[N];
    for(int i=0;i<n;i++){
        scanf("%s",ch);
        for(int j=0;j<n;j++){
            maze[i][j]=ch[j]-'0';
        }
    }
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(!block[i][j]){
                block[i][j]=tag;
                bfs(i,j);
                tag++;//深搜起点 
            }
    int a,b;
    for(int i=0;i<m;i++){
        scanf("%d%d",&a,&b);
        printf("%d\n",ans[block[a-1][b-1]]);//调取询问，输出所属的块的大小即可 
    } 
    return 0; 
}

如下是一份用图论连通图做的，代码注释已经很详细了！！！

//连通图图论优化 
#include<bits/stdc++.h>
using namespace std;
char _map[1001][1001];//_map数组保存地图 
int flag[1001][1001],a[1000001];//a数组要开大一点，刚开始开a[1001]错了3个点 
//flag数组保存各个点所在的连通图，以及是否已经处理过，a数组保存各个连通图的大小
struct mg
{
    int x,y;
}q[1000001];
int main()
{
    int sx,sy,i,j,n,m,l,nx,ny,k,f,r,sum,d;
    int dx[4]={0,0,-1,1};
    int dy[4]={1,-1,0,0};//四个方向
    scanf("%d %d",&n,&m);//n是正方形地图边长，m是数据组数 
    for(i=1;i<=n;i++)
{
        for(j=1;j<=n;j++){
            cin>>_map[i][j];//读入地图 

    }
    }
    d=0;//d用来保存当前是在第几个连通图中 
    for(i=1;i<=n;i++)
{
        for(j=1;j<=n;j++)
{
            if(flag[i][j]==0)//如果当前位置不在已知连通图中（还未处理过） 
            {
                d++;//记录当前所在连通图数 
                f=1;
                r=1;
                q[f].x=i;
                q[f].y=j;
                flag[i][j]=d;
                sum=1;//初始化
                while(f<=r)
{
                    for(k=0;k<4;k++){
                        nx=q[f].x+dx[k];
                        ny=q[f].y+dy[k];
                        if(flag[nx][ny]==0&&nx>=1&&nx<=n&&ny>=1&&ny<=n&&((_map[nx][ny]=='1'&&_map[q[f].x][q[f].y]=='0')||(_map[nx][ny]=='0'&&_map[q[f].x][q[f].y]=='1')))
                        //如果新位置能走且在地图上 
                        {
                            r++;
                            sum++;//计数器累加 
                            flag[nx][ny]=d;//标记新位置在第d个连通图中 
                            q[r].x=nx;
                            q[r].y=ny;//更新位置 
                        }
                    }
                    f++;
                }
                a[d]=sum;//保存当前连通图能移动到多少格 
            }
    for(i=1;i<=m;i++)
    {
        cin>>sx>>sy;//读入询问 
        cout<<a[flag[sx][sy]]<<endl;//直接查找答案并输出 
    }
    return 0;
}

大家如果学过图论这就是一道求连通图的基础