用递归java求解迷宫

我正试图找到通往终点的路。这是一个递归函数。请帮帮我，我就要自杀了

这是给定的地图

 { 1, 1, 1, 1 },
 { 0, 0, 1, 0 },
 { 0, 0, 1, 0 },
 { 0, 0, 1, 0 }};

我想递归地使用GetPath来到达上面映射中的结束位置。参数是currentPosition、end position和map。对于本例，起始位置为（0,0），结束位置为（0,3），右上角。0表示墙，1表示路径

我需要返回一个填充了有效点的arraylist到结束位置。虽然我的数组大小始终为0，并且基本大小写永远不会返回路径。如何跟踪arraylist中的位置

请帮忙，我会很感激的

  private ArrayList<Point> GetPath(Point CurrentPosition, Point EndPosition, int[][] Map)
    { 
    System.out.println("Current Position: " + CurrentPosition.toString());
    ArrayList<Point> p = new ArrayList<Point>();
    Path.add(CurrentPosition);

    if (CurrentPosition.equals(EndPosition))
    {

        return Path;
       }

        Map[(int)CurrentPosition.getX()][(int) CurrentPosition.getY()] = 0; //setting to 0 so my function wont revisit that position in the map 
ArrayList<Point> p2 = new ArrayList<Point>();    //Array for the 4 points around the CurrentPosition
        p2.add(new Point((int) CurrentPosition.getX(), (int) CurrentPosition.getY()+1));
        p2.add(new Point((int) CurrentPosition.getX()+1, (int) CurrentPosition.getY()));
        p2.add(new Point((int) CurrentPosition.getX(), (int) CurrentPosition.getY()-1));
        p2.add(new Point((int) CurrentPosition.getX()-1, (int) CurrentPosition.getY()));


    for (int i = 0; i < p2.size(); i++)
    {
        int j = 0;
        if (((p2.get(i).getX() >= 0 && p2.get(i).getY() >= 0) && (p2.get(i).getX() < Map.length && p2.get(i).getY() < Map[0].length)) && Map[(int) p2.get(i).getX()][(int) p2.get(i).getY()] !=0) //if the points in the array are within range and if the points aren't equal to 0.
        {
            Map[(int)p2.get(i).getX()][(int)p2.get(i).getY()] = 0; 
           GetPath(p2.get(i), EndPosition, Map); //recursive method

          }

        }

    return Path;

private ArrayList GetPath（点CurrentPosition、点EndPosition、int[]Map）
{ 
System.out.println（“当前位置：+CurrentPosition.toString（））；
ArrayList p=新的ArrayList（）；
添加路径（当前位置）；
if（当前位置等于（结束位置））
{
返回路径；
}
Map[（int）CurrentPosition.getX（）][（int）CurrentPosition.getY（）]=0；//设置为0，以便我的函数不会重新访问映射中的该位置
ArrayList p2=new ArrayList（）；//当前位置周围4个点的数组
p2.添加（新点（（int）CurrentPosition.getX（），（int）CurrentPosition.getY（）+1））；
p2.添加（新点（（int）CurrentPosition.getX（）+1，（int）CurrentPosition.getY（））；
p2.添加（新点（（int）CurrentPosition.getX（），（int）CurrentPosition.getY（）-1））；
p2.添加（新点（（int）CurrentPosition.getX（）-1，（int）CurrentPosition.getY（））；
对于（int i=0；i=0&&p2.get（i）.getY（）>=0）和（&&p2.get（i）.getX（）

---

}

创建一个以起始和结束位置为参数的函数。让它扫描每一条路径，寻找清晰的道路。所以，如果你能去北，西，南，东扫描这些位置的“1”。如果您找到1，让函数再次调用自身，并将找到“1”的点作为新的起始位置。通过到目前为止的路径以及目标终点位置。一旦其中一个在给定的结束位置找到“1”的匹配项，您就到达了您的路径。这可能不是最佳路径。如果需要，解析所有可能的路径并选择最短路径。最后，向后遍历路径以获得所有点。由于到目前为止函数作为参数点访问，请确保不再通过从未来路径中排除这些参数点来访问同一点。

我想我可能已经发现了问题：

您从未对递归调用的返回值执行任何操作：

...
 Map[(int)p2.get(i).getX()][(int)p2.get(i).getY()] = 0; 
 GetPath(p2.get(i), EndPosition, Map); //recursive method
...

您应该执行以下操作：

ArrayList<Point> recPath = GetPath(p2.get(i), EndPosition, Map); //recursive method
Path.addAll(recPath);

ArrayList recPath=GetPath（p2.get（i），EndPosition，Map）//递归方法
addAll（recPath）；

实际上，您确实需要在末尾返回路径，毕竟

公共静态列表getPath（点开始、点结束、int[]Map）
public static List<Point> getPath(Point start, Point end, int[][] Map)
{

    //Current Position for the currentPosition
    // EndPosition, given any point in the map would be the end of the maze
    // map is that map that given for example or any other map
    // returns an arraylist of positions of the paths
    ArrayList<Point> result = new ArrayList<Point>();
    boolean solutionExists = buildSolution(start, end, Map, result, new HashSet<Point>());
    return solutionExists? result : null;
}

public static boolean buildSolution(Point current, Point end, int[][] map, List<Point> solution, Set<Point> visited) {
    visited.add(current);
    if (current.equals(end)) {
        solution.add(current);
        return true;
    }
    if (map[current.x][current.y] == 0) {
        return false;
    }
    Set<Point> neighbours = getNeighbours(current, map);
    neighbours.removeAll(visited);
    for (Point neighbour : neighbours) {
        ArrayList<Point> temp = new ArrayList<Point>();
        Set<Point> tempVisited = new HashSet<Point>(visited);
        tempVisited.add(neighbour);
        if (buildSolution(neighbour, end, map, temp, tempVisited)) {
            solution.add(current);
            solution.addAll(temp);
            return true;
        }
    }
    return false;
}

public static Set<Point> getNeighbours(Point current, int[][] map) {
    int maxX = map.length - 1;
    int maxY = map[0].length - 1;
    Set<Point> result = new HashSet<Point>();
    result.add(new Point(current.x, current.y - 1 < 0 ? current.y :current.y -1));
    result.add(new Point(current.x, current.y + 1 > maxY ? current.y : current.y +1));
    result.add(new Point(current.x - 1 < 0 ? current.x : current.x -1 , current.y));
    result.add(new Point(current.x + 1 > maxX ? current.x : current.x  + 1, current.y));
    result.remove(current);
    return result;
}

{
//currentPosition的当前位置
//EndPosition，给定地图上的任何点都将是迷宫的终点
//地图是给定的地图或任何其他地图
//返回路径位置的arraylist
ArrayList结果=新建ArrayList（）；
布尔solutionExists=buildSolution（开始、结束、映射、结果、新HashSet（））；
返回solutionExists？结果：空；
}
公共静态布尔构建解决方案（点当前、点结束、int[][]映射、列表解决方案、访问集）{
已访问。添加（当前）；
如果（当前等于（结束））{
解决方案。添加（当前）；
返回true；
}
if（map[current.x][current.y]==0）{
返回false；
}
设置邻居=获取邻居（当前，映射）；
邻居。移除所有（已访问）；
用于（点邻居：邻居）{
ArrayList temp=新的ArrayList（）；
Set tempVisited=新哈希集（已访问）；
添加（邻居）；
if（构建解决方案（邻居、结束、映射、临时、临时访问））{
解决方案。添加（当前）；
溶液。添加全部（温度）；
返回true；
}
}
返回false；
}
公共静态集GetNeights（点电流，int[][]映射）{
int maxX=map.length-1；
int maxY=map[0]。长度-1；
Set result=new HashSet（）；
结果.添加（新点（当前.x，当前.y-1<0？当前.y:当前.y-1））；
结果.添加（新点（当前.x，当前.y+1>最大？当前.y:current.y+1））；
结果.添加（新点（当前x-1<0？当前x:current.x-1，当前y））；
结果.添加（新点（当前.x+1>maxX？当前.x:current.x+1，当前.y））；
结果：删除（当前）；
返回结果；
}

类似的问题，您可能想检查一下：似乎不需要for循环。只要传入新点作为递归调用中更新的当前位置。forloop将访问数组中的4个可能点，如果我不使用forloop，我将如何访问所有点？@RoyKesserwani好吧，看到你逐个创建了这些点，当你做这些点的时候，你可能已经做了递归调用。这实际上返回了什么？它将从你的递归调用返回路径。所以也许你不想马上归还。对不起，让我编辑一下，你怎么能反向遍历你的路径呢？如果你把上一个点作为参数传递给你的递归函数，你只需要反向递归。如果上一个点指向上一个点，你就回到起点，给我举个例子好吗？我要一个