假设我有以下迷宫:(格式不正确）
#########################################
S... #... # # #... #
###.# ##### #.#.### # ### # ###.#.# #####
#...# #...# #.#...# # # #.#.# #...#
#.#####.#.###.###.##### ##### #.#.###.#.#
#.....#.#..... #...# #.#.....#.#
# ###.#.####### ###.###########.#######.#
# #.#.# # #...#......... # #.#
### #.#.# ### #######.#.########### # #.#
# # #.#.# # # # #...# # # .#
# # #.#.# # ### # # ##### ### # #######.#
# #...# # # # # .E
#########################################
S表示迷宫的开始，E表示迷宫的结束。我有两个给定的课程; Maze和Cell。我必须构建以下递归辅助方法来找到迷宫的解决方案：
-findPath(currentMaze:Maze, current:Cell, path:ArrayList<Cell>):ArrayList<Cell
这种方法 递归地找到从currentMaze开始到结束的路径 目前的细胞。该路径是从中获取的单元序列的ArrayList 迷宫开始到当前的小区（即到目前为止探索的路径）。为了避免路径 这个算法应该避免重新访问此路径中已有的单元格。该 如果没有从当前到结束的路径，则算法应该返回null 每个Cell最多一次。否则，它应该从迷宫的开始返回完整的路径 最后作为ArrayList中的Cell序列。 您必须将其实现为递归算法。为了探索尚未通过邻居的所有路径 访问过，你会想要使用迷宫的getNeighbors。
为了构建这个递归方法，我给出了以下方法：
+getStartCell():Cell Returns the start Cell of the maze
+getEndCell():Cell Returns the end Cell of the maze
+getNeighbors(currentCell:Cell):
ArrayList<Cell>
Returns a list of all the cells that are connected to
currentCell. If there is a wall between
currentCell and its neighbor, it is not added to this
collection.
到目前为止，这就是我所做的：
private static ArrayList <Cell> findPath(Maze currentMaze,Cell current,ArrayList <Cell> path){
// Base Case
if (current == currentMaze.getEndCell()) {
return path;
}
if(currentMaze.getNeighbors(current).size()!=0)
currentMaze.getStartCell();
currentMaze.getNeighbors(current);
currentMaze.getEndCell();
}
}
我真的很难建立这种方法。
答案 0 :(得分：1)
好在这里。您不仅需要DFS，还需要存储找到的路径。
您为findPath建议的方法签名将无效。它的path参数是一个列表，它会在遍历时存储所有节点，因为即使它是一个递归算法，我们也不会在将列表传递给下一个findPath之前完全复制该列表。调用，坦率地说，我们不应该这样做，以提高性能，减少内存消耗。
我能想到的最简单方法就是让每个单元都指向它的父级。父单元格是将单元格作为邻居发现的单元格。
我们必须为findPath
List<Cell> findPath(Maze currentMaze, Cell current)
当我们到达End node时，我们需要返回所有递归，以便状态必须存储在findPath之外。
休息很简单，我们可以使用以下算法（It＆＃39;伪代码）
path = null
findPath(maze, startCell)
printPath(maze, path)
findPath(currentMaze, current)
if curent = endCell
list = []
while(current != null)
list.add(0, current)
current = current.parent
path = list
else if path != null
current.visitStatus = IN_PROGRESS
neighbours = getUnVisitedNeighbours(current)
for each neibhbour in neighbours
neighbour.parent = current
findPath(currentMaze, neighbour)
current.visitStatus = VISITED
printPath(currentMaze, path)
for each cell in path
cell.ch = 'O' //since path references are same as maze it will update maze as well
print maze
注意：此算法不会产生最短路径，只要能找到任何路径就会返回。
这是一个实际的Java实现。它从文本文件中读取迷宫。
以下是带有示例迷宫文本文件的Github链接。
https://github.com/ConsciousObserver/stackoverflow/tree/master/TestMaze
package com.example;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Stream;
import com.example.TestMaze.Cell.VisitStatus;
public class TestMaze {
static List<Cell> resultPath = null;
public static void main(String[] args) {
String filePath = "maze2.txt";
Maze currentMaze = new Maze(filePath);
findPath(currentMaze, currentMaze.startCell);
if(resultPath == null) {
System.out.println("\nNo path exists for the Maze");
} else {
System.out.println("\nPath size : " + resultPath.size());
printPathOnMaze(currentMaze, resultPath);
}
}
private static void printPathOnMaze(Maze maze, List<Cell> path) {
path.stream()
.filter(cell-> !maze.isStartCell(cell) && !maze.isEndCell(cell))
.forEach(cell-> cell.setCh('O'));
maze.printCells();
}
private static List<Cell> findPath(Maze currentMaze, Cell current) {
if(currentMaze.isEndCell(current)) {
resultPath = new ArrayList<>();
Cell traversalCell = current;
while(traversalCell != null) {
resultPath.add(0, traversalCell);
traversalCell = traversalCell.getParentCell();
}
return resultPath;
}
if(resultPath == null) {
if(Maze.isWall(current)) {
current.setVisitStatus(VisitStatus.VISITED);
} else {
current.setVisitStatus(VisitStatus.IN_PROGRESS);
List<Cell> neighbourList = currentMaze.getNeighbours(current);
neighbourList.stream()
.filter(cell -> cell.getVisitStatus() == VisitStatus.UNVISITED)
.filter(cell -> cell.getVisitStatus() == VisitStatus.UNVISITED)
.forEach(neighbour -> {
neighbour.setParentCell(current);
findPath(currentMaze, neighbour);
});
current.setVisitStatus(VisitStatus.VISITED);
}
}
return null;
}
public static boolean isCellInPath(Cell cell, List<Cell> path) {
return path.stream().anyMatch(c -> c.getI() == cell.getI() && c.getJ() == c.getJ());
}
public static class Cell {
private int i, j;
private char ch;
private Cell parentCell;
public enum VisitStatus {VISITED, IN_PROGRESS, UNVISITED};
private VisitStatus visitStatus = VisitStatus.UNVISITED;
public Cell(int i, int j, char ch) {
super();
this.i = i;
this.j = j;
this.ch = ch;
}
public int getI() {
return i;
}
public int getJ() {
return j;
}
public char getCh() {
return ch;
}
public void setCh(char ch) {
this.ch = ch;
}
public VisitStatus getVisitStatus() {
return visitStatus;
}
public void setVisitStatus(VisitStatus visitStatus) {
this.visitStatus = visitStatus;
}
public Cell getParentCell() {
return parentCell;
}
public void setParentCell(Cell parentCell) {
this.parentCell = parentCell;
}
}
public static class Maze {
private Cell[][] grid;
private Cell startCell;
private Cell endCell;
private static final char START_CELL_CHAR = 'S';
private static final char END_CELL_CHAR = 'E';
private static final char WALL_CHAR = '#';
private static final char EMPTY_SPACE_CHAR = '.';
public Maze(String filePath) {
grid = createFromFile(filePath);
printCells();
}
public Cell[][] getGrid() {
return grid;
}
public Cell getStartCell() {
return startCell;
}
public Cell getEndCell() {
return endCell;
}
public boolean isStartCell(Cell cell) {
return startCell.getI() == cell.getI() && startCell.getJ() == cell.getJ();
}
public boolean isEndCell(Cell cell) {
return endCell.getI() == cell.getI() && endCell.getJ() == cell.getJ();
}
List<Cell> getNeighbours(Cell cell) {
List<Cell> neighboursList = new ArrayList<>();
int mazeHeight = grid.length;
int mazeWidth = grid[0].length;
if(cell.getI() - 1 > 0) {
neighboursList.add(grid[cell.getI() - 1][cell.getJ()]);
}
if(cell.getI() + 1 < mazeHeight) {
neighboursList.add(grid[cell.getI() + 1][cell.getJ()]);
}
if(cell.getJ() - 1 > 0) {
neighboursList.add(grid[cell.getI()][cell.getJ() - 1]);
}
if(cell.getJ() + 1 < mazeWidth) {
neighboursList.add(grid[cell.getI()][cell.getJ() + 1]);
}
return neighboursList;
}
public static boolean isWall(Cell cell) {
return cell.getCh() == WALL_CHAR;
}
public static boolean isEmptySpace(Cell cell) {
return cell.getCh() == EMPTY_SPACE_CHAR;
}
public void printCells() {
Stream.of(grid).forEach(row-> {
Stream.of(row).forEach(cell -> System.out.print(cell.getCh()) );
System.out.println();
});
}
private Cell[][] createFromFile(String filePath) {
Cell[][] maze = null;
try(Scanner scan = new Scanner(Paths.get(filePath)) ) {
List<Cell[]> list = new ArrayList<>();
for(int i = 0; scan.hasNext(); i++) {
String line = scan.nextLine();
char[] chArr = line.toCharArray();
Cell[] row = new Cell[chArr.length];
for(int j = 0; j < chArr.length; j++) {
char ch = chArr[j];
Cell cell = new Cell(i, j, ch);
row[j] = cell;
if(ch == START_CELL_CHAR) {
startCell = cell;
} else if (ch == END_CELL_CHAR) {
endCell = cell;
}
}
list.add(row);
}
if(startCell == null || endCell == null) {
throw new RuntimeException("Start cell or End cell not present");
}
maze = list.toArray(new Cell[][]{});
} catch(Exception ex) {
ex.printStackTrace();
}
return maze;
}
}
}
注意：您的样本没有解决方案。
示例输入，其中包含解决方案
#########################################
S....#....#.#.#....#.........#..........E
###.#.#####.#.#.###.#.#.#.#.###.#.#.#####
#...#.#...#.#.#...#.#.#.#.#.#.#...#......
#.#####.#.###.###.#####..####.#.#.###.#.#
#.....#.#......#...#.#.#.....#.#.........
#.###.#.#######.###.########.##.#######.#
#.#.#.#.#.#...#..........#.#.#...........
###.#.#.#.###.#######.#.####.######.#.#.#
#.#.#.#.#.#.#.#.#...#.#.#..#.............
#.#.#.#.#.#.###.#.#.#####.###.#.#######.#
#.#.....................................#
#########################################
<强>输出
Path size : 89
#########################################
SOOO.#....#.#.#....#.........#...OOOOOOOE
###O#.#####.#.#.###.#.#.#.#.###.#O#.#####
#OOO#.#...#.#.#...#.#.#.#.#.#.#..O#..OOO.
#O#####.#.###.###.#####..####.#.#O###O#O#
#OOOOO#.#......#...#.#.#.....#.#.OOOOO.O.
#.###O#.#######.###.########.##.#######O#
#.#.#O#.#.#...#..........#.#.#.........O.
###.#O#.#.###.#######.#.####.######.#.#O#
#.#.#O#.#.#.#.#.#OOO#.#.#..#.OOO.......O.
#.#.#O#.#.#.###.#O#O#####.###O#O#######O#
#.#..OOOOOOOOOOOOO.OOOOOOOOOOO.OOOOOOOOO#
#########################################
注意：广度优先搜索可能会带来更好的结果。
答案 1 :(得分：0)
问问自己如何找到路径。在每一步都考虑到达一些细胞。
类似的东西：
private static ArrayList <Cell> findPath(Maze currentMaze,Cell current,ArrayList <Cell> currentPath, ArrayList< ArrayList <Cell> > solutionsFound){
// step 1
if (currentPath.exists(current)) {
return;
}
// step 2
currentPath.add(current);
// step 3
if(current == currentMaze.getStartCell()){
solutionsFound.add(currentPath.clone());
currentPath.remove(current);
return;
}
// step 4
ArrayList<Cell> neighbors = currentMaze.getNeighbors(current);
for(int i=0;i<neighbors.size();i++){
findPath(currentMaze, neighbors[i], currentPath, solutionsFound);
}
// step 5
currentPath.remove(current);
}
从：
开始ArrayList< ArrayList <Cell> > solutionsFound = new ArrayList< ArrayList <Cell> >();
ArrayList <Cell> currentPath= new ArrayList <Cell> ();
findPath(currentMaze, currentMaze.getStartCell(), new ArrayList <Cell>, solutionsFound);
最后，solutionsFound包含解决方案，currentPath应为空。