[Retrospectiva] C035_openj_ mini-juego (hay un problema con la entrada / registrar la dirección del precursor)

1. problema

El juego se juega en un tablero rectangular dividido en cuadrículas cuadradas. Como se muestra en la figura, puede haber una tarjeta de juego en cada cuadrícula cuadrada, por supuesto, no puede haber ninguna.

Cuando se cumplen las siguientes condiciones, creemos que hay un camino entre las dos cartas de juego:

La ruta contiene solo segmentos rectos u horizontales. El camino no puede pasar a través de otras cartas de juego. Sin embargo, el camino puede dejar temporalmente la placa rectangular. Aquí hay un ejemplo:

Aquí se pueden conectar las tarjetas de juego en (1, 3) y (4, 4). Las tarjetas de juego en (2, 3) y (3, 4) no están conectadas, porque cada ruta que las conecta debe pasar por otras tarjetas de juego.

Ahora tienes que determinar en el minijuego si hay un camino que satisfaga el problema y pueda conectar las dos cartas de juego dadas.

De entrada

La entrada incluye múltiples conjuntos de datos. Una placa rectangular corresponde a un conjunto de datos. La primera línea incluida en cada conjunto de datos incluye dos enteros w y h (1 <= w, h <= 75), que representan respectivamente el ancho y la longitud de la placa rectangular. Las siguientes líneas h, cada línea incluye caracteres w, indican la distribución de las tarjetas de juego en el tablero rectangular. Use 'X' para indicar que hay una tarjeta de juego en este lugar; use un espacio para indicar que no hay una tarjeta de juego en este lugar.

Cada una de las siguientes líneas incluye 4 enteros x1, y1, x2, y2 (1 <= x1, x2 <= w, 1 <= y1, y2 <= h). Indique la posición de las dos cartas en el tablero rectangular (nota: las coordenadas de la esquina superior izquierda del tablero rectangular son (1, 1)). La entrada garantiza que las posiciones de las dos cartas de juego no son las mismas. Si hay 4 ceros seguidos, significa el final de este conjunto de datos de prueba.

Si w = h = 0 se da en una línea, significa que toda la entrada ha terminado.

Salida

Para cada placa rectangular, genere una línea "Placa #n:", donde n es el número de datos de entrada. Luego, envíe una línea por cada grupo de tarjetas de juego que se probarán. El comienzo de esta línea es "Pair m:", donde m es el número de la tarjeta de prueba (para cada tablero rectangular, el número comienza desde 1). A continuación, si se puede conectar, encuentre todas las rutas que conectan las dos tarjetas, incluida la ruta con el menor número de segmentos de línea, y envíe "k segmentos", donde k es el número de segmentos de línea incluidos en la ruta óptima encontrada; "Imposible". Es la salida.

Se genera una línea en blanco después de cada conjunto de datos.

样例输入
5 4
XXXXX
X   X
XXX X
 XXX 
2 3 5 3
1 3 4 4
2 3 3 4
0 0 0 0
0 0
样例输出
Board #1:
Pair 1: 4 segments.
Pair 2: 3 segments.
Pair 3: impossible.

Segundo, solución

Método 1: dfs

Puntos novedosos:

• Dirección de pregrabación precursora, si la dirección actual k es la misma que la pre, no se requieren pasos adicionales.
• De lo contrario, actualice la dirección actual a k, y deje step+1.

Poda:

• Si el valor del paso actual es mayor que min, no hay necesidad de continuar buscando.

Hay un problema con la entrada: ¿puedes ayudar a ver si hay algún problema ? La entrada ha sido incorrecta.

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	static int ex, ey, R, C;
	static char[][] grid;
	static boolean[][] vis;
	static boolean reach;
	static int min, INF = 0x3f3f3f3f;
	final static int[][] dir = { {0,1},{0,-1},{1,0},{-1,0} };

	static boolean inArea(int x, int y) {
		return x >= 0 && x < R+2 && y >= 0 && y < C+2;
	}
	static void dfs(int x, int y, int step, int pre) {
		if (step > min)
			return;
		if (x == ex && y == ey) {
			if (step < min)
				min = step;
			return;
		}
		for (int k = 0; k < 4; k++) {
			int tx = x + dir[k][0];
			int ty = y + dir[k][1];
			if (!inArea(tx, ty) || vis[tx][ty] || grid[tx][ty] != ' ')
				continue;
			if (tx == ex && ty == ey && grid[tx][ty] == 'X') {
				vis[tx][ty] = true;
				if (pre == k)
					dfs(tx, ty, step, pre);
				else 
					dfs(tx, ty, step+1, k);
				vis[tx][ty] = false;
			}
		}
	}
    public static void main(String[] args) throws IOException {  
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
		int cnt = 1;
		while (true) {
		    C = sc.nextInt();
			R = sc.nextInt();
			if (R == 0 && C == 0)
			    return;
			grid = new char[R+50][C+50];
			for (int i = 0; i < R+2; i++) grid[i][0] = ' ';
			for (int i = 0; i < C+2; i++) grid[0][i] = ' ';
			for (int i = 1; i < R+1; i++) {
				String s = sc.next();
				for (int j = 1; j < C+1; j++) {
					grid[i][j] = s.charAt(j-1);
				}
			}
			for (int i = 0; i < R+2; i++) grid[R+1][i] = ' ';
			for (int i = 0; i < C+2; i++) grid[i][C+1] = ' ';
			int pair = 1;
			while (true) {
				int sx = sc.nextInt();
				int sy = sc.nextInt();
				ex = sc.nextInt();
				ey = sc.nextInt();
				if (sx == 0 && sy == 0 && ex == 0 && ey == 0)
				    break;
				dfs(sx, sy, 0, -1);
				System.out.printf("Board #%d:\n", cnt++);
				if (reach) {
					System.out.printf("Pair %d: %d segments.\n", pair++, min);
				} else {
					System.out.printf("Pair %d: impossible.\n", pair++);
				}
				reach = false;
				min = INF;
			}
			sc.next();
		}
    }
}

Análisis de complejidad.

• Complejidad del tiempo: $O ()$，
• Complejidad espacial: $O ()$，

---

Método dos:

Análisis de complejidad.

• Complejidad del tiempo: $O ()$，
• Complejidad espacial: $O ()$，