[Retrospectiva] C035_openj_ minijogo (há um problema com a entrada / registro da direção do precursor)

1. Problema

O jogo é jogado em um tabuleiro retangular dividido em grades quadradas de w * h. Como mostrado na figura, pode haver uma carta de jogo em cada grade quadrada; é claro, não pode haver nenhuma.

Quando as seguintes condições são atendidas, acreditamos que existe um caminho entre as duas cartas de jogo:

O caminho contém apenas segmentos retos ou horizontais. O caminho não pode passar por outros cartões de jogo. No entanto, o caminho pode deixar temporariamente a placa retangular. Aqui está um exemplo:

Aqui os cartões de jogo em (1, 3) e (4, 4) podem ser conectados. Os cartões de jogo em (2, 3) e (3, 4) não estão conectados, porque cada caminho que os conecta deve passar por outros cartões de jogo.

Agora você precisa determinar no mini-jogo se existe um caminho que satisfaça o problema e se pode conectar as duas cartas de jogo.

Entrada

A entrada inclui vários conjuntos de dados. Uma placa retangular corresponde a um conjunto de dados. A primeira linha incluída em cada conjunto de dados inclui dois números inteiros w eh (1 <= w, h <= 75), respectivamente representando a largura e o comprimento da placa retangular. As seguintes linhas h, cada linha inclui w caracteres, indicam a distribuição de cartas de jogo no tabuleiro retangular. Use 'X' para indicar que há uma carta de jogo neste local; use um espaço para indicar que não há uma carta de jogo neste local.

Cada uma das linhas a seguir inclui 4 números inteiros x1, y1, x2, y2 (1 <= x1, x2 <= w, 1 <= y1, y2 <= h). Indique a posição das duas cartas no quadro retangular (nota: as coordenadas do canto superior esquerdo do quadro retangular são (1, 1)). A entrada garante que as posições das duas cartas de jogo não sejam as mesmas. Se houver 4 zeros seguidos, significa o final desse conjunto de dados de teste.

Se w = h = 0 é dado em uma linha, significa que toda a entrada terminou.

Saída

Para cada placa retangular, imprima uma linha "Board #n:", em que n é o número dos dados de entrada. Em seguida, imprima uma linha para cada grupo de cartas de jogo a serem testadas. O início desta linha é "Par m:", em que m é o número do cartão de teste (para cada placa retangular, o número começa em 1). Em seguida, se puder ser conectado, encontre todos os caminhos que conectam as duas placas, incluindo o caminho com o menor número de segmentos de linha, e emita "k segmentos". Onde k é o número de segmentos de linha incluídos no caminho ideal encontrado; "Impossível". É saída.

Uma linha em branco é emitida após cada conjunto de dados.

样例输入
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, Solução

Método 1: dfs

Novos pontos:

• Direção de pré-gravação do precursor, se a direção atual k for a mesma que pré, nenhuma etapa adicional será necessária.
• Caso contrário, atualize a direção atual para ke deixe step+1.

Poda:

• Se o valor atual da etapa for maior que min, não será necessário continuar a pesquisa.

Há um problema com a entrada: você pode ajudar a ver se há algum problema ? A entrada está incorreta.

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álise de complexidade

• Complexidade do tempo: $O()$，
• Complexidade do espaço: $O()$，

---

Método dois:

Análise de complexidade

• Complexidade do tempo: $O()$，
• Complexidade do espaço: $O()$，