Question

我正在尝试找到EndPosition的路径。这是一个递归函数。请帮助，我即将自杀。

这是给定的地图

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

我想以递归方式使用GetPath来获取上面地图中的EndPosition。参数是currentPosition，结束位置和地图。对于此示例，起始位置为（0,0）并且结束，EndPosition为（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;

}

Answer 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);

在所有

之后，你实际上确实需要return Path

Answer 2

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

Answer 3

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;
}

用递归java解决迷宫

3 个答案: