[Retour en arrière] C033_openj_LETTERS (faux)

1. Titre Description

Étant donné une matrice de lettres majuscules ligne × col, la position initiale est le coin supérieur gauche, vous pouvez vous déplacer vers le haut, le bas, la gauche et la droite dans quatre directions, et vous ne pouvez pas vous déplacer vers les lettres qui sont passées. Demandez un maximum de quelques lettres.

Entrée

Dans la première ligne, entrez le numéro R de la matrice de lettres et le nombre S de colonnes, 1≤R, S≤20.
Puis sortez la matrice de lettres de la ligne R et de la colonne S.

Sortie

Nombre maximal de lettres différentes pouvant être traversées.

3 6
HFDFFB
AJHGDH
DGAGEH

输出样例
6

Deuxièmement, la solution

Méthode 1: dfs

Mauvaise idée: utiliser un ensemble pour stocker directement les caractères passés par chaque étape. Si les caractères répétés sont traversés, nous sautons et retournons finalement la taille de l'ensemble.

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());
    }
}

Vérifiez les lacunes: quand il est possible de traverser, il y a beaucoup de caractères dans le jeu, qui sont plus grands que la taille du dernier jeu, mais vous n'êtes pas allé enregistrer en temps réel. J'ai donc changé le code en ceci:

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]);
	}
}

Ou WA (5 points): Pourquoi? Il s'agit d'une question de retour en arrière ... Il est déjà évident que la question commence au point de départ et demande les caractères les plus différents transmis, c'est-à-dire que nous devons exécuter la grille entière à partir de chaque position, plutôt que de simplement exécuter une série à partir du point de départ , Cette complexité est $O (R × C)$ , le retraçage est $O (niveau d'index)$

Le code est corrigé comme suit:

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);
    }
}

Analyse de complexité

• Complexité temporelle: $O (niveau d'index)$ ,
• Complexité de l'espace: $O (R × C)$，