01 solución de laberinto

Enlace del título original
Descripción del título:
Hay un laberinto de cuadrícula n × n compuesto solo por los números 0 y 1. Si está en una cuadrícula 0, puede moverse a una cuadrícula 1 entre las 4 cuadrículas adyacentes, y si está en una cuadrícula 1, puede moverse a una cuadrícula 0 entre las 4 cuadrículas adyacentes.
Tu tarea es: Para un laberinto dado, pregunta a cuántas cuadrículas (incluyéndote a ti mismo) puedes moverte desde una determinada cuadrícula.

Entrada:
La línea 1 contiene dos enteros positivos n, m.
Las siguientes n líneas, cada línea tiene n caracteres, los caracteres solo pueden ser 0 o 1, y no hay espacio entre los caracteres.
En las próximas m líneas, dos enteros positivos i y j separados por espacios en cada línea corresponden a una cuadrícula en la fila i y la columna j en el laberinto, y pregunte cuántas cuadrículas puede mover de esta cuadrícula.

Salida:
m líneas, para cada consulta salida la respuesta correspondiente.

Entrada de estilo:

2 2
01
10
1 1
2 2

Salida de estilo:

4
4

Idea del tema:
dfs es recorrer cada ruta una vez, como el primer método, tratando de visitar arriba, abajo, izquierda y derecha cada vez, siempre que coincida, entrar y luego visitar arriba, abajo, izquierda y derecha. correcto de nuevo, pero debemos prestar atención. No es necesario registrar el juicio del límite y los lugares recorridos, y usar una matriz para marcarlo, de modo que cada posición solo se registre una vez.
Pero en términos de comprensión, puede recordar que solo registro cada ubicación una vez, por lo que me encuentro en un callejón sin salida, pero ¿qué debo hacer si no hay un camino en mi ubicación? De hecho, en tu caso, es un callejón sin salida, por lo que este dfs ha terminado, y luego saltarás de este dfs y entrarás en el siguiente dfs, es decir, has vuelto a tu posición anterior.
Uno de tus clones se ha ido, pero has usado varios clones de sombra en cada intersección. Esto se debe a que estás lleno de determinación, haciendo que los clones lleguen al callejón sin salida sin arrepentirse.

Esta es la primera forma de escribir, pero hay espacio para la optimización, pero este método puede ser más fácil de entender.

#include<bits/stdc++.h>
using namespace std;
int n, m, ans;
char arr[1001][1001];
bool yong[1001][1001];///用于标记位置是否走过

void df(int x, int y) {
    
    
	if (x - 1 >= 1 && x - 1 <= n && arr[x - 1][y] != arr[x][y] && yong[x - 1][y] == 0) {
    
    //shang
		ans++;
		yong[x - 1][y] = 1;
		df(x - 1, y);
	}if (x + 1 >= 1 && x + 1 <= n && arr[x + 1][y] != arr[x][y] && yong[x + 1][y] == 0) {
    
    //xia
		ans++;
		yong[x + 1][y] = 1;
		df(x + 1, y);
	}if (y - 1 >= 1 && y - 1 <= n && arr[x][y - 1] != arr[x][y] && yong[x][y - 1] == 0) {
    
    //zuo
		ans++;
		yong[x][y - 1] = 1;
		df(x, y - 1);
	}if (y + 1 >= 1 && y + 1 <= n && arr[x][y + 1] != arr[x][y] && yong[x][y + 1] == 0) {
    
    //you
		ans++;
		yong[x][y + 1] = 1;
		df(x, y + 1);
	}
}

int main() {
    
    
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
    
    
		getchar();
		for (int j = 1; j <= n; j++) {
    
    
			cin >> arr[i][j];
		}
	}
	int a, b;
	for (int i = 1; i <= m; i++) {
    
    
		memset(yong, 0, sizeof(yong));
		ans = 1;
		cin >> a >> b;
		yong[a][b] = 1;
		df(a, b);
		cout << ans << endl;
	}
	return 0;
}

El segundo método Este método se usa a menudo en el problema del laberinto de bfs para reducir la cantidad de código y hacer que el código sea más fácil de mantener y verificar.

#include<bits/stdc++.h>
using namespace std;
int n, m, ans;
char arr[1001][1001];//绘制地图
int yong[1001][1001];//标记位置
int X[]={
    
    0,0,-1,1};
int Y[]={
    
    -1,1,0,0};

bool text(int x,int y,int number){
    
    
	if(yong[x][y])return 0;//如果这个位置走过了，就不再走了返回false 
	if(x<1||y>n||y<1||x>n)return 0; //判断x，y是否越过边界 
	if(arr[x][y]==number)return 0;//和上个位置的数字比较，相同就不可走
	return 1;
}

void dfs(int x,int y){
    
    
	for(int i=0;i<4;i++){
    
    
		int newX=x+X[i];
		int newY=y+Y[i];
		if(text(newX,newY,arr[x][y])){
    
    
			ans++;
			yong[newX][newY]=1;
			dfs(newX,newY);
		}
	}
}

int main() {
    
    
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
    
    
		getchar();
		for (int j = 1; j <= n; j++) {
    
    
			cin >> arr[i][j];
		}
	}
	int a, b;
	for (int i = 1; i <= m; i++) {
    
    
		memset(yong, 0, sizeof(yong));
		ans = 1;
		cin >> a >> b;
		yong[a][b] = 1;
		dfs(a, b);
		cout << ans << endl;
	}
	return 0;
}