目前我正在尝试解决一个程序，该程序确定是否可以解决迷宫，如果迷宫是可解决的，它应该打印出通过迷宫路径的步数。起始位置和结束位置以及迷宫在输入文件中以下列格式给出：
第 1 行：测试用例（N）
对于每 N 行，第一行将包含迷宫的大小，将给出起始位置和结束出口位置。然后迷宫的视觉描述也将出现在输入文件中
例如，这个挑战的样本输入是：
3
6 7 0 0 5 6
1110111
1011101
1001001
1011101
1000001
1111110
3 3 2 0 0 2
111
110
111
5 5 1 0 3 1
01111
11001
01001
01001
01111
迷宫的确切规则是 0 是不可穿透的墙壁，而 1 是可以四处走动的自由行走空间。结束位置也没有用任何特殊字符标记，而是给了我们位置。
以下代码是我应对挑战的方法，显然不起作用：
import java.io.*;
import java.util.*;
public class Maze
{
public static void main(String[] args) throws FileNotFoundException
{
Scanner sc = new Scanner(new File("maze.txt"));
int tc = sc.nextInt();
for(int p = 0; p < tc; p++ ) {
int rows = sc.nextInt();
int cols = sc.nextInt();
int startRow = sc.nextInt();
int startCol = sc.nextInt();
int endRow = sc.nextInt();
int endCol = sc.nextInt();
sc.nextLine();
char[][] maze = new char[rows][cols];
for(int i = 0; i < rows; i++) {
String s = sc.nextLine();
for(int j = 0; j < cols; j++) {
maze[i][j] = s.charAt(j);
}
}
if(solvable(maze,startRow,startCol,endCol,endRow)) {
int count = 0;
for(char[] arr : maze) {
for(char elem: arr) {
if(elem == 'x') count++;
}
}
System.out.println("It takes " + count + " steps to solve the maze");
}else {
System.out.println("Unsolvable");
}
}
}
public static boolean solvable(char[][] maze,int row, int col,int finishRow, int finishCol) {
if(row < 0 || col < 0 || row >maze.length - 1 || col > maze[0].length - 1) {
return false;
}
if(row == finishRow && col == finishCol) {
return true;
}
if(maze[row][col] == 0) {
return false;
}
char c = maze[row][col];
maze[row][col] = 'x';
if(solvable(maze,row + 1,col,finishRow,finishCol)) {
return true;
}
if(solvable(maze,row - 1,col,finishRow,finishCol)){
return true;
}
if(solvable(maze,row ,col + 1,finishRow,finishCol)) {
return true;
}
if(solvable(maze,row,col - 1,finishRow,finishCol)) {
return true;
}
maze[row][col] = c;
return false;
}
}
如标题所示，该程序会产生堆栈溢出错误。我正在合并解决迷宫的通用算法，而不是合并洪水填充算法。我需要找出可解决的递归方法中的缺陷。请注意，这是一个竞争性的编程环境，因此从 java 的面向对象方面进行编码会很不方便。