[Dfs] B_CodeForce 377_A laberintos (problema de bloque conectado)

1. Título Descripción

A Pavel le gusta el laberinto de cuadrícula. Un laberinto de cuadrícula es un laberinto rectangular n × m en el que cada celda está en blanco o en una pared. Puede caminar de una celda a otra, siempre que ambas celdas estén en blanco y tengan un borde común.

Pavel dibuja un laberinto de cuadrícula, y todas las celdas en blanco contenidas forman un área conectada. En otras palabras, puede pasar de cualquier celda en blanco a cualquier otra celda en blanco. Si el laberinto de Pavel tiene muy pocas paredes, no le gusta. Espera convertir k celdas en blanco en paredes, para que todas las celdas restantes puedan formar un área conectada. Por favor ayúdelo a lograr esta tarea.

De entrada

La primera línea contiene tres enteros n, m, k (1 ≤ n, m ≤ 500, 0 ≤ k <s), donde n y m son la altura y el ancho del laberinto, respectivamente, y k es el número de paredes que Pavel desea unir , Y la letra s indica el número de celdas en blanco en el laberinto original.

En las siguientes n líneas, cada línea contiene m caracteres. Describen el laberinto original. Si un carácter en una fila es igual a ".", La celda correspondiente está en blanco; si el carácter es igual a "#", la celda es un muro.

Salida

Imprima n líneas, cada línea contiene m caracteres: un nuevo laberinto que satisface las necesidades de Pavel. Identifique las celdas en blanco originales que se han convertido en paredes como "X"; otras celdas deben dejarse sin cambios (es decir, "." Y "#").

Garantía de datos: hay una solución. Si hay varias soluciones, puede generar cualquiera de ellas.

输入
3 4 2
#..#
..#.
#...
输出
#.X#
X.#.
#...

输入
5 4 5
#...
#.#.
.#..
...#
.#.#
输出
#XXX
#X#.
X#..
...#
.#.#

En segundo lugar, la solución

Método 1: dfs

• La pregunta asegura que debe haber una respuesta, lo que reduce la dificultad en cierta medida, ¿por qué?
• Cada vez que vamos tan lejos como búsqueda profunda a otra parte, por lo que vamos a ir a otra parte a lo largo del punto de ajuste X, puede garantizar la cifra .aún está conectado.

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	static int N, M, k;
	static char[][] grid;
	static boolean[][] vis;
	final static int[][] dir = { {0,1},{0,-1},{1,0},{-1,0} };
	static boolean inArea(int x, int y) {
		return x >= 0 && x < N && y >= 0 && y < M;
	}
	
	static void dfs(int x, int y) {
		for (int k = 0; k < 4; k++) {
			int tx = x + dir[k][0];
			int ty = y + dir[k][1];
			if (!inArea(tx, ty) || grid[tx][ty] != '.' || vis[tx][ty]) {
				continue;
			}
			vis[tx][ty] = true;
			dfs(tx, ty);
		}
		if (k > 0) {
		    grid[x][y] = 'X';
		    k--;
		}
		    
	}
    public static void main(String[] args) throws IOException {  
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		N = sc.nextInt();
		M = sc.nextInt();
		k = sc.nextInt();
		grid = new char[N][M];
		vis = new boolean[N][M];
		for (int i = 0; i < N; i++) {
			String s = sc.next();
			for (int j = 0; j < M; j++) 
				grid[i][j] = s.charAt(j);
		}
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < M; j++) {
				if (grid[i][j] == '.')
					dfs(i, j);
			}
		}
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < M; j++) {
				System.out.print(grid[x][y]);
			}
			System.out.println();
		}
    }
}

Análisis de complejidad.

• Complejidad del tiempo: $O (n × m)$，
• Complejidad espacial: $O (n × m)$，

Avanzado: si la pregunta no garantiza una respuesta, ¿cómo debe abordar este problema?
Mi enfoque es: una vez que el BFS malla, determina si hay al menos el tamaño de un n*m-kmarcador de bloque de bloque de comunicación y la comunicación, y finalmente atravesar la rejilla de nuevo, no marcado .como Xpuede ser.

---

Método 2: bfs

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	static int N, M, k;
	static char[][] grid;
	static boolean[][] vis;
	final static int[][] dir = { {0,1},{0,-1},{1,0},{-1,0} };
	static int cnt, sum, diff;
	static boolean inArea(int x, int y) {
		return x >= 0 && x < N && y >= 0 && y < M;
	}
	static void bfs(int x, int y) {
		Queue<int[]> q = new ArrayDeque<>();
		q.add(new int[] {x, y});
		vis[x][y] = true;
		cnt = 1;
		
		while (!q.isEmpty()) {
			int[] t = q.poll();
			for (int k = 0; k < 4; k++) {
				int tx = t[0] + dir[k][0];
				int ty = t[1] + dir[k][1];
				if (!inArea(tx, ty))
					continue;
				if (grid[tx][ty] == '.' && !vis[tx][ty]) {
			    	if (cnt == diff) {
		    	    	return;
			    	}
    				q.add(new int[]{tx, ty});
    				vis[tx][ty] = true;
				    cnt++;
				}
			}
		}
	}
    public static void main(String[] args) throws IOException {  
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		N = sc.nextInt();
		M = sc.nextInt();
		k = sc.nextInt();
		grid = new char[N][M];
		vis = new boolean[N][M];
		int sx = -1, sy = -1;
		
		for (int i = 0; i < N; i++) {
			String s = sc.next();
			for (int j = 0; j < M; j++)  {
				grid[i][j] = s.charAt(j);
				if (grid[i][j] == '.') {
					sum++;
					sx = i; sy = j;
				}
			}
		}
		if (sx == -1 && sy == -1) {
			System.out.println(-1);
			return;
		}
		diff = sum - k;
		bfs(sx, sy);
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < M; j++) {
				if (vis[i][j] && grid[i][j] == '.') {
					System.out.print('.');
				} else if (!vis[i][j] && grid[i][j] == '.') {
					System.out.print('X');
				} else {
					System.out.print('#');
				}
			}
			System.out.println();
		}
    }
}

Análisis de complejidad.

• Complejidad del tiempo: $O (n × m)$，
• Complejidad espacial: $O (n × m)$，