Ayuda backtraking laberinto

[fenixskate]

Hola amigos, espero y se encuentren bien, queria saber si me pueden ayudar, necesito hacer un backtraking de laberinto tengo q leer un txt, y guardarlo en un arreglo bidimensional y luego hacer la busqueda mas corta, ya tengo la parte donde lee el txt

Código (java) [Seleccionar] Expandir

if (tecla == KeyEvent.VK_R) {
ObtenerTxt txt = new ObtenerTxt();

txt.obtieneLaberinto();


}

public class ObtenerTxt {
char entradaE = 'e';
char salidaS = 's';
int inicioFila = 0;
int inicioColumna = 0;
int finFila = 0;
int finColumna = 0;
int tam = 0;

char[][] lectura = new char[15][15];

public char[][] obtieneLaberinto() {

try {
String cadena = "";
int filas = 0;
int columnas = 0;
//JFileChooser file = new JFileChooser();

//int seleccion = file.showOpenDialog(null);

//file.showOpenDialog(null);

//if (seleccion == JFileChooser.APPROVE_OPTION) {
File abre = new File("C:\\Users\\pionitos\\Documents\\Nueva Carpeta (3)\\x.txt"); // file.getSelectedFile();
FileReader fr = new FileReader(abre);
BufferedReader entrada = new BufferedReader(fr);
while ((cadena = entrada.readLine()) != null) {
for (int i = 0; i < cadena.length(); i++) {
lectura[filas][columnas] = cadena.charAt(i);
this.setLectura(lectura);

this.setTam(tam = cadena.length());
if (cadena.charAt(i) == entradaE) {
this.setInicioFila(filas);
this.setInicioColumna(columnas);
}
if (cadena.charAt(i) == salidaS) {
this.setFinFila(filas);
this.setFinColumna(columnas);
}
columnas++;
}

filas++;
columnas = 0;

}
//}

for (int i = 0; i < lectura.length; i++) {
for (int j = 0; j < lectura.length; j++) {
System.out.print(lectura[i][j]);

}
System.out.println("");
}
return lectura;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}

public int getTam() {
return tam;
}

public void setTam(int tam) {
this.tam = tam;
}

public char[][] getLectura() {
return lectura;
}

public void setLectura(char[][] lectura) {
this.lectura = lectura;
}

public int getInicioFila() {
return inicioFila;
}

public void setInicioFila(int inicioFila) {
this.inicioFila = inicioFila;
}

public int getInicioColumna() {
return inicioColumna;
}

public void setInicioColumna(int inicioColumna) {
this.inicioColumna = inicioColumna;
}

public int getFinFila() {
return finFila;
}

public void setFinFila(int finFila) {
this.finFila = finFila;
}

public int getFinColumna() {
return finColumna;
}

public void setFinColumna(int finColumna) {
this.finColumna = finColumna;
}

}


y la parte de busqueda
public class Laberinto {

private static char L = 'L'; // pared
private static char E = '0'; // espacio en blanco
private static char MARCA = '*'; // señala las posiciones visitadas
private static int x0 = 1; // inicio X
private static int y0 = 0; // inicio Y
/*
* private static int xf = 11; // salida X private static int yf = 20; //
* salida Y
*/

private static ObtenerTxt txt = new ObtenerTxt();

public static boolean valida(int f, int c) {
// controla si la posicion esta fuera del laberinto
if (f < 0 || f == txt.inicioFila || c < 0 || c == txt.inicioColumna) {
return false;
}
// controla si la posicion ya fue visitada o es muro
if (txt.getLectura()[f][c] == MARCA || txt.getLectura()[f][c] == L) {
return false;
}
return true;
}

public static boolean recorre(int fil, int col) {
boolean listo = false; // Indica si se ha encontrado la salida
// Se marca la casilla como visitada
txt.getLectura()[fil][col] = MARCA;
// Condicion de termino de recursividad: " Llegamos a la salida ?"
if (fil == txt.finFila - 2 && col == txt.finColumna - 1) {
return (true);
}
if (!listo && valida(fil - 1, col)) { /* Intento hacia arriba */
listo = recorre(fil - 1, col);
}
if (!listo && valida(fil, col + 1)) { /* Intento a la derecha */
listo = recorre(fil, col + 1);
}
if (!listo && valida(fil + 1, col)) { /* Intento hacia abajo */
listo = recorre(fil + 1, col);
}
if (!listo && valida(fil, col - 1)) { /* Intento a la izquierda */
listo = recorre(fil, col - 1);
}

if (!listo) {
txt.getLectura()[fil][col] = E;
}
// Se retorna true / false dependiendo de si se encontro solucion
return (listo);
}

public static void main(String[] args) {
System.out.println("LABERINTO PROPUESTO:");
desplegarArreglo(txt.lectura);
System.out.println("LABERINTO RESUELTO");
recorre(x0, y0);
desplegarArreglo(txt.lectura);
}

public static void desplegarArreglo(char[][] matriz) {
for (int i = 0; i < matriz.length; ++i) {
String texto = new String("");
for (int j = 0; j < matriz.length; ++j) {
texto += matriz[i][j] + " ";
}
System.out.println(texto);
}
}
}
pero al momento de querer buscar no logro que me muestre elr esultado, espero y me puedan orientar. gracias
este es mi resultado
este es mi txt.

Código [Seleccionar] Expandir

LLLLLLLLLLLLLLL
L0000000000000L
L0000000000000L
L0000000000000L
L0000000000000L
L0000000000000L
L00000s0000000L
L0000000000000L
L0000000000000L
L000000000e000L
L0000000000000L
L0000000000000L
L0000000000000L
L0000000000000L
LLLLLLLLLLLLLLL

la parte e = entrada, s= salida.

me podrian ayudar, ya que no estoy muy familiarizado con los arreglos. o explicar por favor gracias


Mod: Los códigos deben ir en etiquetas GeSHi