[luogu p1141] 01迷宫

传送门

题面

题目描述

有一个仅由数字\(0\)与\(1\)组成的\(n \times 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\le 10\)；

对于\(40\%\)的数据，\(n\le 50\)；

对于\(50\%\)的数据，\(m\le 5\)；

对于\(60\%\)的数据，\(n\le 100,m\le 100\)；

对于\(100\%\)的数据，\(n\le 1000,m\le 100000\)。

分析

这道题看似是一个很简单的搜索，但从这道题的数据范围看，就能看出这道题其实暗藏杀机。而且最近搜索水腻歪了，看着这道题，我突然灵光乍现：可不可以用并查集做呢？
可以吧，显然我们可以求连通块，那么我们就可以构造映射。二维映射到一维相信大家都已经是轻车熟路了，直接将(i,j)映射到i*n+j，简单粗暴。
关于并查集的细节我并不想说太多，我只是想说，并查集真的是世界上最美的数据结构。
当时我用的是普通的二维数组dfs跑并查集，但结果MLE了3个点，取得了70分的好成绩。
至于MLE，我们就可以整个地图搞成滚动数组，用并查集，都是简单的事情。
具体见代码吧。

代码

先给dfs版本的，注意这个版本我得了70分，别直接拿去抄以后我还得注意一下空间复杂度，这是个教训啊。

/*
 * @Author: crab-in-the-northeast 
 * @Date: 2020-02-19 23:01:54 
 * @Last Modified by: crab-in-the-northeast
 * @Last Modified time: 2020-02-19 23:41:37
 */

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 1005;
const int maxn2 = 1000005;

int n;
int fa[maxn2],u[maxn2];
bool a[maxn][maxn];
int dx[4] = {1,-1,0,0};
int dy[4] = {0,0,1,-1}; 

int find(int x){//查
    return fa[x] == x?x:fa[x] = find(fa[x]);
}

void merge(int a,int b){//并
    int fa1 = find(a), fa2 = find(b);
    if(fa1 != fa2){
        u[fa1] += u[fa2];
        fa[fa2] = fa[fa1];
    }
}

// 以上都是并查集的板子，这里不再多说。

bool valid(int x,int y){
    return x>0&&x<=n&&y>0&&y<=n;
}//边界判断。

int dfs(int x,int y){
    int ind = x*n+y;//映射处理
    if(fa[ind] != -1) return find(ind);//记忆化
    fa[ind] = ind;
    u[ind] = 1;
    //初始化

    for(int i=0;i<4;i++){
        int nxtx = x+dx[i], nxty = y+dy[i];//枚举下一种情况的x坐标和y坐标。
        if(valid(nxtx,nxty) && a[x][y]!=a[nxtx][nxty])//合法。
            merge(ind,dfs(nxtx,nxty));//并。
    }
    
    return find(ind);//回溯
}

int main(){
    int T;
    scanf("%d%d",&n,&T);
    memset(fa,-1,sizeof(fa));
    for(int i = 1; i <= n ;i++)
        for(int j = 1; j <= n; j++)
            scanf("%1d",&a[i][j]);

    while(T--){
        int x,y;
        scanf("%d%d",&x,&y);
        printf("%d\n",u[dfs(x,y)]);
    }
    return 0;
}

满分AC代码(采用滚动数组)

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 1005;
const int maxn2 = 1000005;

int n;
int fa[maxn2],u[maxn2];
char a[2][maxn];

int find(int x){
    return fa[x] == x?x:fa[x] = find(fa[x]);
}

void merge(int a,int b){
    int fa1 = find(a), fa2 = find(b);
    if(fa1 != fa2){
        u[fa1] += u[fa2];
        fa[fa2] = fa[fa1];
    }
}

int main(){
    int T;
    scanf("%d%d",&n,&T);
    memset(fa,-1,sizeof(fa));
    for(int i = 0; i < n; i++){
        scanf("%s",a[i&1]);//读入
        for(int j = 0; j < n; j++){
            int ind = i*n+j;//映射
            fa[ind] = ind;
            u[ind] = 1;
            if(i && a[(i-1)&1][j] !=a[i&1][j]) merge(ind-n,ind);//横向并
            if(j && a[i&1][j-1] != a[i&1][j]) merge(ind,ind-1);//纵向并
        }
    }

    while(T--){
        int x,y;
        scanf("%d%d",&x,&y);
        printf("%d\n",u[find(x*n-n+y-1)]);
        //这里蟹蟹懒。这里的原型应该是(x-1)*n+y-1，就是用了个乘法分配。
    }
    return 0;
}

评测结果

MLE 70：R30836609AC 100：R30837084

over.