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

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.

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