我想找到从一个点到另一个点的路径。黑匣子是障碍物，我们不能去它，蓝色框是起点，黄色框是我想从起点到终点的终点。我借助我书中的算法编写了这段代码，实际上现在我想让它成为动态的，意味着n x n矩阵。所以我想要指导我应该采取哪些步骤使其能够运行n x n矩阵。我还想问一下，这是在这种情况下找到最短路径的最佳解决方案吗？
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
boolean[][] boolMaze = new boolean[][] {
{ true, true, true, true, true },
{ false, true, false, true, true },
{ true, false, true, true, true },
{ false, true, true, false, false },
{ false, false, false, false, false },
{ true, true, true, true, true },
{ false, true, false, true, true },
{ true, false, true, true, true },
{ false, true, true, false, false },
{ false, false, false, false, false },
{ true, true, true, true, true },
{ false, true, false, true, true },
{ true, false, true, true, true },
{ false, true, true, false, false },
{ false, false, false, false, false },
{ true, true, true, true, true },
{ false, true, false, true, true },
{ true, false, true, true, true },
{ false, true, true, false, false },
{ false, false, false, false, false } };
Maze maze = new Maze(boolMaze);
List<Maze.Cell> path = maze.findPath(0, 0, 3, 2);
System.out.println("found path in maze: " + path);
}
}
class Maze {
private final boolean[][] maze;
public Maze(boolean[][] maze) {
this.maze = maze;
}
public int height() {
return maze.length;
}
public int width() {
return maze[0].length;
}
}
public List<Cell> findPath(int xStart, int yStart, int xGoal, int yGoal) {
LinkedList<Cell> path = new LinkedList(); // use a linked list, since we
// don't know how many
// elements it will contain
// straight away..
path.add(new Cell(xStart, yStart));
HashSet<Cell> visited = new HashSet(); // this set will store all
// visited cells. Make sure to
// add any cell you looked at.
// Don't work with cells which
// you have visited previously,
// by checking
// visited.contains(cell).
visited.add(path.getFirst());
// ///////////////////////////
if (xStart - 1 >= 0 && maze[xStart][yStart - 1]) {
Cell cell = new Cell(xStart, yStart - 1);
return path;
}
else if (yStart + 1 < height() && maze[xStart][yStart + 1]) {
Cell cell = new Cell(xStart, yStart + 1);
return path;
}
else if (xStart + 1 < width() && maze[xStart + 1][yStart]) {
Cell cell = new Cell(xStart + 1, yStart);
return path;
}
else if (xStart - 1 >= 0 && maze[xStart - 1][yStart]) {
Cell cell = new Cell(xStart - 1, yStart);
return path;
}
// //////////////////////////
// use your path finding algorithm here (note that you can use getLast()
// and getFirst() on your list.
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof Cell))
return false;
Cell cell = (Cell) o;
if (x != cell.x)
return false;
return y == cell.y;
}
@Override
public int hashCode() {
int result = x;
result = 31 * result + y;
return result;
}
class Cell implements Comparable<Cell> {
Cell(int x, int y) {
this.x = x;
this.y = y;
}
int x;
int y;
@Override
public int compareTo(Cell o) {
if (o.equals(x) && o.equals(y))
return 0;
return 1;
}
}
答案 0 :(得分：1)
您的问题分为两部分。首先是使解决方案适用于NxM迷宫，另一个是风格和性能改进。
首先，使用查找和替换可以快速修复两件事。
Integer。 Integer是必须由垃圾收集器创建和销毁的实际对象。此外，每次使用它们进行计算时都必须进行转换，这会严重影响性能。boolean[][] 请同时删除路线阵列。这是毫无意义的，因为directions[i] == i总是true。你可以一直使用int变量。甚至可以使用枚举更好的解决方案，但不要在这里引入太多新概念..
此代码：
for(int i = 0; i < directions.length; i++) {
Cell newCell = findCell(current,directions[i]);
//code..
}
将成为此代码：
for(int i = 0; i < 4; i++) {
Cell newCell = findCell(current,i);
//code..
}
然后你应该开始使用迷宫作为一个对象，因为它已经是一个类。
您必须从所有变量和方法中删除static关键字，因为它们将来会对私有成员起作用
创建一个名为Class的新Main，您可以在新添加的主方法中调用以下代码：
boolean[][] boolMaze = new boolean[][]{/*initialize array*/};
Maze maze = new Maze(boolMaze);
List<Cell> path = maze.findPath(0, 0, 3, 2);
System.out.println("found path in maze: "+path)
所以我们需要两件新事物。适用于Maze的构造函数和方法findPath。
类Maze应该包含私有（可能是最终的）成员boolean[][]迷宫，构造函数应该设置它。
public Maze(boolean[][] maze) {
this.maze = maze;
}
同时删除变量WIDTH和HEIGHT，因为它们不一定反映数组的大小。关于java的好处是，数组会记住它们具有的大小。添加公共帮助程序函数以便快速访问：
public int height() {
return maze.length;
}
public int width() {
return maze[0].length; // assuming that maze.length is always > 0
}
findPath方法应创建List<Cell>并将其返回：
public List<Cell> findPath(int xStart, int yStart, int xGoal, int yGoal) {
LinkedList<Cell> path = new LinkedList(); //use a linked list, since we don't know how many elements it will contain straight away..
path.add(new Cell(xStart, yStart));
HashSet<Cell> visited = new HashSet(); //this set will store all visited cells. Make sure to add any cell you looked at. Don't work with cells which you have visited previously, by checking visited.contains(cell).
visited.add(path.getFirst());
//use your path finding algorithm here (note that you can use getLast() and getFirst() on your list.
return path;
}
然后您还可以删除单元格中的父属性。要比较两个Cell是否相同，请不要使用比较。该方法用于对对象进行排序。
实现：
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Cell)) return false;
Cell cell = (Cell) o;
if (x != cell.x) return false;
return y == cell.y;
}
@Override
public int hashCode() {
int result = x;
result = 31 * result + y;
return result;
}
在Cell。检查两个Cell是否相同时，请致电cell.equals(otherCell)
您实际上实施了一个洪水填充算法，这意味着您只需天真地填充整个飞机，直到找到目标为止。 解决迷宫的标准算法总是试图坚持到一面墙。 请注意，只有当您的入口点和目标位于迷宫的边缘时（例如通常情况下），这才有效 使用this网站了解有关该算法的更多信息 您可能希望保留路径查找算法，并且只有在您的起点和目标位于边缘旁边时才使用改进的算法。