[Retroceso] C033_openj_LETTERS (incorrecto)

1. Título Descripción

Dada una matriz de mayúscula fila × col, la posición inicial es la esquina superior izquierda, puede moverse hacia arriba, abajo, izquierda y derecha en cuatro direcciones, y no puede moverse a las letras que han pasado. Pide un máximo de algunas letras.

De entrada

En la primera fila, ingrese el número R de la matriz de letras y el número S de columnas, 1≤R, S≤20.
Luego, envíe la matriz de letras de la fila R y la columna S.

Salida

El número máximo de letras diferentes que se pueden atravesar.

3 6
HFDFFB
AJHGDH
DGAGEH

输出样例
6

En segundo lugar, la solución

Método 1: dfs

Idea equivocada: use un conjunto para almacenar los caracteres pasados ​​por cada paso directamente.Si se atraviesan los caracteres repetidos, omitimos y finalmente devolvemos el tamaño del conjunto.

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	static int R, C;
	static char[][] g;
	final static int[][] dir = { {1, 0}, {0, -1}, {-1, 0}, {0, 1}};
	static boolean[][] vis;
	static Set<Character> set;
	
	private 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 (tx < 0 || tx >= R || ty < 0 || ty >= C || vis[tx][ty] || set.contains(g[tx][ty]))
				continue;
			vis[tx][ty] = true;
			set.add(g[tx][ty]);
			dfs(tx, ty);
		}
	}
    public static void main(String[] args) throws IOException {  
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
        
		R = sc.nextInt();
		C = sc.nextInt();
		g = new char[R][C];
		for(int i = 0; i < R; i++) {
			String s = sc.next();
			for(int j = 0; j < C; j++) {
				g[i][j] = s.charAt(j);
			}
		}
		vis = new boolean[R][C];
		set = new HashSet<>();
		vis[0][0] = true;
		set.add(g[0][0]);
		dfs(0, 0);
		System.out.println(set.size());
    }
}

Verifique las lagunas: cuando es posible atravesar, hay muchos caracteres en el conjunto, que son más grandes que el tamaño del último conjunto, pero no fue a grabar en tiempo real. Entonces cambié el código a esto:

private static void dfs(int x, int y)  {
    max = Math.max(set.size(), max);
	for (int k = 0; k < 4; k++) {
		int tx = x + dir[k][0];
		int ty = y + dir[k][1];
		if (tx < 0 || tx >= R || ty < 0 || ty >= C || vis[tx][ty] || set.contains(g[tx][ty]))
			continue;
		vis[tx][ty] = true;	//注
		set.add(g[tx][ty]);
		dfs(tx, ty);
		set.remove(g[tx][ty]);
	}
}

O WA (5 puntos): ¿Por qué? Esta es una pregunta de retroceso ... Ya es obvio que la pregunta comienza desde el punto de partida y solicita los caracteres más diferentes pasados, es decir, tenemos que ejecutar toda la cuadrícula desde cada posición, en lugar de simplemente ejecutar una serie desde el punto de partida Esta complejidad es $O (R × C)$ , el rastreo es $O (nivel de índice)$

El código se corrige de la siguiente manera:

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	static int R, C;
	static char[][] g;
	final static int[][] dir = { {1, 0}, {0, -1}, {-1, 0}, {0, 1}};
	static boolean[][] vis;
	static Set<Character> set;
	static int max;
	private static void dfs(int x, int y)  {
	    max = Math.max(set.size(), max);
		for (int k = 0; k < 4; k++) {
			int tx = x + dir[k][0];
			int ty = y + dir[k][1];
			if (tx < 0 || tx >= R || ty < 0 || ty >= C|| set.contains(g[tx][ty]))
				continue;
			set.add(g[tx][ty]);
			dfs(tx, ty);
			set.remove(g[tx][ty]);
		}
	}
    public static void main(String[] args) throws IOException {  
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
		R = sc.nextInt();C = sc.nextInt();
		g = new char[R][C];
		for(int i = 0; i < R; i++) {
			String s = sc.next();
			for(int j = 0; j < C; j++) {
				g[i][j] = s.charAt(j);
			}
		}
		set = new HashSet<>();
		set.add(g[0][0]);
		dfs(0, 0);
		System.out.println(max);
    }
}

Análisis de complejidad.

• Complejidad del tiempo: $O (nivel de índice)$ ,
• Complejidad espacial: $O (R × C)$，