Java学习迷宫求解器

我一直在编写一些代码，引导一个“机器人”穿过一个有多个死胡同和一条正确路径的迷宫，到达如下目标：

我使用了一个堆栈来记录机器人第一次到达一个有3个或4个可能出口的广场时所面对的方向，如果已经访问了所有相邻的广场，则使用pop（）使机器人从它最初到达的方向返回（与到达的方向相反）。在运行结束时，堆栈包含到达目标路线上所有方块的方向。按照堆栈的相反方向将机器人从目标带回到起点。我正在努力找出如何使用这个堆栈，以便在下一次运行时，机器人将采取最佳路径达到目标

我的一些代码：

private int pollRun = 0; // Incremented after each pass
private int explorerMode; // 1 = explore, 0 = backtrack

public void exploreControl(IRobot robot) {

  byte exits = nonwallExits(robot);
  int direction;

  switch (exits) { //passes control to respective method
    case 1: direction = deadEnd(robot);   break;
    case 2: direction = corridor(robot); break;
    case 3: direction = junction(robot); break;
    default: direction = crossroads(robot); break;
  }

  if (exits == 1) {explorerMode = 0;}

  robot.face(direction); 

  pollRun++;

}

public void backtrackControl(IRobot robot) {

  byte exits = nonwallExits(robot);
  int direction = IRobot.CENTRE;

  switch (exits) { //passes control to respective method
    case 1: direction = deadEnd(robot);   break;
    case 2: direction = corridor(robot); break;
    default: direction = junction(robot); break; // do nothing
  }

  if (exits > 2) {
    if (passageExits(robot) > 0){
      exploreControl(robot);
      explorerMode = 1;
      pollRun++;
      return;
    } else {
      robot.setHeading(st.pop());
      robot.face(IRobot.BEHIND);
      pollRun++;
      return;
    }

  }

    robot.face(direction); 

  pollRun++;

}

public void optimal(IRobot robot) {

  byte exits = nonwallExits(robot);
  int direction;
  int heading;

  for(int i = 0; i < st.size(); i++) {
    stNew.push(st.pop());
  }

  if (exits < 3) {

    switch (exits) { //passes control to respective method
      case 1: direction = deadEnd(robot);   break;
      default: direction = corridor(robot); break;
    }

    robot.face(direction);

  } else {
    robot.setHeading(stNew.pop());
  }

}

public void controlRobot(IRobot robot) {

  if ((robot.getRuns() == 0) && (pollRun == 0)) {
    robotData = new RobotData(); //reset the data store
    explorerMode = 1;
  }

  if (robot.getRuns() = 1) {
    optimal(robot);
    return;
  }

  if (robot.getRuns() <= 0 && (nonwallExits(robot) >= 3)
      && (beenbeforeExits(robot) <= 0)) {
    st.push(robot.getHeading());
  }

  if (explorerMode == 1) {
    exploreControl(robot);
  } else {backtrackControl(robot);}

}

private int pollRun=0；//每次通过后递增
私有int explorerMode；//1=探索，0=回溯
公共空间探索控制（IRobot机器人）{
字节出口=非墙壁出口（机器人）；
int方向；
开关（退出）{//将控制传递给相应的方法
案例1：方向=终端（机器人）；中断；
案例2：方向=走廊（机器人）；中断；
案例3：方向=连接（机器人）；中断；
默认值：方向=十字路口（机器人）；断开；
}
如果（exits==1）{explorerMode=0；}
机器人。脸（方向）；
pollRun++；
}
公共无效回溯控制（IRobot机器人）{
字节出口=非墙壁出口（机器人）；
内部方向=IRobot.center；
开关（退出）{//将控制传递给相应的方法
案例1：方向=终端（机器人）；中断；
案例2：方向=走廊（机器人）；中断；
默认值：方向=连接（机器人）；中断；//不执行任何操作
}
如果（退出>2）{
如果（passageExits（robot）>0）{
探索控制（机器人）；
explorerMode=1；
pollRun++；
返回；
}否则{
robot.setHeading（st.pop（））；
机器人。脸（IRobot。后面）；
pollRun++；
返回；
}
}
机器人。脸（方向）；
pollRun++；
}
公共空间优化（IRobot机器人）{
字节出口=非墙壁出口（机器人）；
int方向；
int标题；
对于（int i=0；i&&（beenbeforeExits（robot）的确，这个问题可以通过使用堆栈和对迷宫的穷举搜索来解决。有更有效的方法，但这个方法会奏效

很难知道你的代码是如何运行的，因为你只给出了它的一部分。然而，一般来说，这些穷举式搜索大量使用递归——这是堆栈的一个非常常见的用例。我假设你的代码也是这样，尽管我在你提供的示例中看不到这些代码

以下是一些用于彻底的“深度优先”搜索的psuedo示例代码。此代码最终将提供所有可能的解决方案，而不仅仅是一个。您的代码中应该有一个类似于此的方法

void findPath(Stack currentPath) {
    if (currentPath.peek() == goal) {
        solutions.add(currentPath);
    } else {
        for (Position next: currentPath.openPositions()) {
            currentPath.push(next);
            findPath(currentPath);
            currentPath.pop();
        }
    }
}

“openPositions”方法需要通过查看当前路径来显式停止任何加倍-换句话说，它不应该返回任何已经在currentPath堆栈中的位置，否则将导致无限递归

因为这样可以找到所有可能的解决方案，所以您需要找到长度最短的路径作为最佳路径。在您的情况下，迷宫似乎只有一条路径，因此您可以在找到路径后立即退出

最后一点注意：您尝试将设置机器人需要转向的方向的任务与在迷宫中找到路径的任务相结合。我建议将这些任务分开。使用上述算法找到路径（或更有效的路径，如*）一旦你有了路径，你就可以通过它来确定机器人的方向列表。
我认为堆栈不是正确的方法。要找到最佳解决方案，你需要构建一个完整的迷宫图，然后进行广度优先搜索。这是解决问题的可能方法之一，但我被告知这是一个非常复杂的问题h使用堆栈更简单。如果你建立了一个完整的迷宫图，这会使它成为一个不真实的场景，你需要假设迷宫图对他来说是未知的，想象一个物理机器人在迷宫上试图找到出口，这听起来更像是在一个真实的场景中，你会使用深度搜索并沿着可能的路径行走，记录下沿着t的发现路径他回答道。我以前回答过一个类似的问题，只使用堆栈。不知道这是否有帮助：我在发布这篇文章后再次阅读了你的问题，现在我意识到你试图模拟一个机器人在迷宫中找到路，而不是找到一条最佳路径，然后引导机器人走。这显然是为什么你不能做评论者所说的事情我仍然相信我上面给出的算法是正确的——唯一的变化是你需要一个单独的列表（不是当前路径）来记录搜索过程中的移动。