Java 递归迷宫求解法

我正在研究一种递归求解由单元组成的问题的方法

这种方法根本不起作用。如有任何建议，将不胜感激

参数：srow=起始x值。scol=起始y值erow=结束 x值。ecol=结束y值。L=已求解路径点的链接列表

代码：

专用输入图形；
私有int R，C；
//由我添加的代码
私有字符串[][]单元格//用于跟踪已被证明是死胡同的细胞的阵列。
公开您的MazeWithPath2（）
{       
//一个R行x C列迷宫
迷宫=新输入图形maze2（）；
R=maze.Rows（）；C=maze.Cols（）；
//由我添加的代码
单元格=新字符串[R+2][C+2]；
对于（int i=0；i这是一个基本的图遍历问题。我建议您使用dfs而不是bfs。几乎任何关于算法和数据结构的教科书都会有实现

您只需调整递归部分，在达到目标后停止搜索。另一方面，如果您要查找到目标的所有路径，只需对所有路径执行所有操作，然后再从那里开始。有关提示，您可以查看Bellman–Ford或Dijkstra的算法(http://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm).再说一遍，任何一本有图表章节的好教科书。
为了用不太冗长的语言来理解这个问题，请看
这个小小的JS递归迷宫解算器由用户@Sergey Rudenko制作

var map = [
    [1,1,0,0,0,0,0,0],
    [0,1,1,0,0,0,0,0],
    [1,1,1,0,0,0,0,0],
    [1,0,0,1,1,1,1,1],
    [1,1,0,0,1,0,0,1],
    [0,1,1,0,1,0,0,1],
    [1,1,1,0,1,0,0,1],
    [1,0,0,0,1,1,1,1]
]

var goalx = 7;
var goaly = 7;

function findpath(x,y){

    // illegal move check
    if (x < 0 || x > (map[0].length -1) || y < 0 || y > (map.length - 1)) return false; //if it is outside of map
    if (map[y][x]==0) return false; //it is not open

    // end move check
    if (x== goalx && y== goaly){
        console.log('Reached goal at: ' + x + ':' + y);
        return true; // if it is the goal (exit point)
    }

    if(map[y][x] == 9 || map[y][x] == 8)
        return false;

    console.log('Im here at: ' + x + ':' + y);

    map[y][x]=9; //here marking x,y position as part of solution path outlined by "9"

    if(findpath(x+1,y)) 
        return true;    
    if(findpath(x,y+1)) 
        return true;    
    if(findpath(x,y-1))
        return true;
    if(findpath(x-1,y)) 
        return true;                    

    return false;
};

findpath(0, 0);

var映射=[
[1,1,0,0,0,0,0,0],
[0,1,1,0,0,0,0,0],
[1,1,1,0,0,0,0,0],
[1,0,0,1,1,1,1,1],
[1,1,0,0,1,0,0,1],
[0,1,1,0,1,0,0,1],
[1,1,1,0,1,0,0,1],
[1,0,0,0,1,1,1,1]
]
var-goalx=7；
var goaly=7；
函数findpath（x，y）{
//非法移动检查
if（x<0 | | x>（map[0].length-1）| y<0 | | y>（map.length-1））返回false；//如果它在map之外
if（map[y][x]==0）返回false；//未打开
//末端移动检查
如果（x==goalx&&y==goaly）{
log（'在：'+x+'时达到目标：'+y）；
返回true；//如果是目标（退出点）
}
if（map[y][x]==9 | | map[y][x]==8）
返回false；
log（'Im在这里：'+x+'：'+y）；
映射[y][x]=9；//此处将x，y位置标记为“9”所勾勒的解决方案路径的一部分
if（findpath（x+1，y））
返回true；
if（findpath（x，y+1））
返回true；
if（findpath（x，y-1））
返回true；
if（findpath（x-1，y））
返回true；
返回false；
};
findpath（0,0）；


是的，它很小，很简单，很幼稚，也很缺乏，但见鬼，它是递归的，而且很有效！
此外，您可以清楚地看到许多迷宫遍历算法的公共部分

对于一个更严肃的阅读，有优秀的深度，但不是关于许多游戏相关算法的科学论文教程

在购买算法时，有一些相关问题需要回答：

需要什么解决办法吗

需要所有解决方案吗

需要最快的吗

迷宫的地形是什么？网格？图形

未来想实施移动成本吗

想要实施启发式来选择最佳路线吗

最后，如果你还没有遇到它，请检查a*算法。非常流行

玩得开心！
你不是已经在另一个问题中问过这个问题了吗？@Vipar是的，我尝试过删除它。我把它缩小到问题所在的这个方法，并决定开始一个新的线程。
var map = [
    [1,1,0,0,0,0,0,0],
    [0,1,1,0,0,0,0,0],
    [1,1,1,0,0,0,0,0],
    [1,0,0,1,1,1,1,1],
    [1,1,0,0,1,0,0,1],
    [0,1,1,0,1,0,0,1],
    [1,1,1,0,1,0,0,1],
    [1,0,0,0,1,1,1,1]
]

var goalx = 7;
var goaly = 7;

function findpath(x,y){

    // illegal move check
    if (x < 0 || x > (map[0].length -1) || y < 0 || y > (map.length - 1)) return false; //if it is outside of map
    if (map[y][x]==0) return false; //it is not open

    // end move check
    if (x== goalx && y== goaly){
        console.log('Reached goal at: ' + x + ':' + y);
        return true; // if it is the goal (exit point)
    }

    if(map[y][x] == 9 || map[y][x] == 8)
        return false;

    console.log('Im here at: ' + x + ':' + y);

    map[y][x]=9; //here marking x,y position as part of solution path outlined by "9"

    if(findpath(x+1,y)) 
        return true;    
    if(findpath(x,y+1)) 
        return true;    
    if(findpath(x,y-1))
        return true;
    if(findpath(x-1,y)) 
        return true;                    

    return false;
};

findpath(0, 0);