EmptyStackException - 二维数组上的 Java 深度优先搜索算法
Posted
技术标签:
【中文标题】EmptyStackException - 二维数组上的 Java 深度优先搜索算法【英文标题】：EmptyStackException - Java Depth First Search algorithm on 2D array 【发布时间】：2019-01-28 13:51:25 【问题描述】：我看过这个问题here 我尝试了那里的大部分代码示例，但是当我在我的代码中使用它时，它只是跳过了算法。
我有这个使用堆栈的 DFS 算法，我得到一个EmptyStackException，我已经调试了算法，在第一次递归搜索后堆栈是空的，第一次搜索有效，但堆栈的大小设置为 0，我在这里想念什么？ github
如何确保第一次搜索后堆栈不为空？
我得到异常的那一行是while(true)AddBridges state = gameTree.peek(); ...
我正在使用 2d 数组从 0 到 4 随机生成节点 0 = null 1-4 = island 每次用户开始游戏时，该数组都会生成随机整数，这是否会导致算法停止，
经过一个周末的调试，我发现算法有时会在搜索 4-6 次后刹车，有时会在第一次搜索后中断。
public int[][] debug_board_state_easy = new int[4][4];
//This Generates random 2d array
private void InitializeEasy()
Random rand = new Random();
setCurrentState(new State(WIDTH_EASY));
for (int row = 0; row < debug_board_state_easy.length; row++)
for (int column = 0; column < debug_board_state_easy[row].length; column++)
debug_board_state_easy[row][column] = Integer.valueOf(rand.nextInt(5));
for (int row = 0; row < debug_board_state_easy.length; row++)
for (int column = 0; column < debug_board_state_easy[row].length; column++)
System.out.print(debug_board_state_easy[row][column] + " ");
System.out.println(debug_board_state_easy);
//I am applying the search algorithm here...
this.search();
for (int row = 0; row < WIDTH_EASY; ++row)
for (int column = 0; column < WIDTH_EASY; ++column)
getCurrentState().board_elements[row][column] = new BoardElement();
getCurrentState().board_elements[row][column].max_connecting_bridges = Integer.valueOf(debug_board_state_easy[row][column]);
getCurrentState().board_elements[row][column].row = row;
getCurrentState().board_elements[row][column].col = column;
if (getCurrentState().board_elements[row][column].max_connecting_bridges > 0)
getCurrentState().board_elements[row][column].is_island = true;
void search()
Map<Point, List<Direction>> remainingOptions = new HashMap<>();
Stack<Land> gameTree = new Stack<>();
gameTree.push(new AddBridges(debug_board_state_easy));
while(true)
AddBridges state = gameTree.peek();
int[] p = state.lowestTodo();
if (p == null)
System.out.println("solution found");
// move to next game state
int row = p[0];
int column = p[1];
System.out.println("expanding game state for node at (" + row + ", " + column + ")");
List<Direction> ds = null;
if(remainingOptions.containsKey(new Point(row,column)))
ds = remainingOptions.get(new Point(row,column));
else
ds = new ArrayList<>();
for(Direction dir : Direction.values())
int[] tmp = state.nextIsland(row, column, dir);
if(tmp == null)
continue;
if(state.canBuildBridge(row,column,tmp[0], tmp[1]))
ds.add(dir);
remainingOptions.put(new Point(row,column), ds);
// if the node can no longer be expanded, and backtracking is not possible we quit
if(ds.isEmpty() && gameTree.isEmpty())
System.out.println("no valid configuration found");
return;
// if the node can no longer be expanded, we need to backtrack
if(ds.isEmpty())
gameTree.pop();
remainingOptions.remove(new Point(row,column));
System.out.println("going back to previous decision");
continue;
Direction dir = ds.remove(0);
System.out.println("connecting " + dir.name());
remainingOptions.put(new Point(row,column), ds);
AddBridgesnextState = new AddBridges(state);
int[] tmp = state.nextIsland(row,column,dir);
nextState.connect(row,column, tmp[0], tmp[1]);
gameTree.push(nextState);
添加桥梁类
public class AddBridges
private int[][] BRIDGES_TO_BUILD;
private boolean[][] IS_ISLAND;
private Direction[][] BRIDGES_ALREADY_BUILT;
public Land(int[][] bridgesToDo)
BRIDGES_TO_BUILD = copy(bridgesToDo);
int numberRows = bridgesToDo.length;
int numberColumns = bridgesToDo[0].length;
BRIDGES_ALREADY_BUILT = new Direction[numberRows][numberColumns];
IS_ISLAND = new boolean[numberRows][numberColumns];
for(int i=0;i<numberRows;i++)
for (int j = 0; j < numberColumns; j++)
BRIDGES_ALREADY_BUILT[i][j] = null;
IS_ISLAND[i][j] = bridgesToDo[i][j] > 0;
public AddBridges (AddBridges other)
BRIDGES_TO_BUILD = copy(other.BRIDGES_TO_BUILD);
int numberRows = BRIDGES_TO_BUILD.length;
int numberColumns = BRIDGES_TO_BUILD[0].length;
BRIDGES_ALREADY_BUILT = new Direction[numberRows][numberColumns];
IS_ISLAND = new boolean[numberRows][numberColumns];
for(int i=0;i<numberRows;i++)
for (int j = 0; j < numberColumns; j++)
BRIDGES_ALREADY_BUILT[i][j] = other.BRIDGES_ALREADY_BUILT[i][j];
IS_ISLAND[i][j] = other.IS_ISLAND[i][j];
public int[] next(int r, int c, Direction dir)
int numberRows = BRIDGES_TO_BUILD.length;
int numberColumns = BRIDGES_TO_BUILD[0].length;
// out of bounds
if(r < 0 || r >=numberRows || c < 0 || c >= numberColumns)
return null;
// motion vectors
int[][] motionVector = -1, 0,0,1,1,0,0,-1;
int i = Arrays.asList(Direction.values()).indexOf(dir);
// calculate next
int[] out = new int[]r + motionVector[i][0], c + motionVector[i][1];
r = out[0];
c = out[1];
// out of bounds
if(r < 0 || r >=numberRows || c < 0 || c >= numberColumns)
return null;
// return
return out;
public int[] nextIsland(int row, int column, Direction dir)
int[] tmp = next(row,column,dir);
if(tmp == null)
return null;
while(!IS_ISLAND[tmp[0]][tmp[1]])
tmp = next(tmp[0], tmp[1], dir);
if(tmp == null)
return null;
return tmp;
public boolean canBuildBridge(int row0, int column0, int row1, int column1)
if(row0 == row1 && column0 > column1)
return canBuildBridge(row0, column1, row1, column0);
if(column0 == column1 && row0 > row1)
return canBuildBridge(row1, column0, row0, column1);
if(row0 == row1)
int[] tmp = nextIsland(row0, column0, Direction.EAST);
if(tmp == null)
return false;
if(tmp[0] != row1 || tmp[1] != column1)
return false;
if(BRIDGES_TO_BUILD[row0][column0] == 0)
return false;
if(BRIDGES_TO_BUILD[row1][column1] == 0)
return false;
for (int i = column0; i <= column1 ; i++)
if(IS_ISLAND[row0][i])
continue;
if(BRIDGES_ALREADY_BUILT[row0][i] == Direction.NORTH)
return false;
if(column0 == column1)
int[] tmp = nextIsland(row0, column0, Direction.SOUTH);
if(tmp == null)
return false;
if(tmp[0] != row1 || tmp[1] != column1)
return false;
if(BRIDGES_TO_BUILD[row0][column0] == 0 || BRIDGES_TO_BUILD[row1][column1] == 0)
return false;
for (int i = row0; i <= row1 ; i++)
if(IS_ISLAND[i][column0])
continue;
if(BRIDGES_ALREADY_BUILT[i][column0] == Direction.EAST)
return false;
// default
return true;
public int[] lowestTodo()
int R = BRIDGES_TO_BUILD.length;
int C = BRIDGES_TO_BUILD[0].length;
int[] out = 0, 0;
for (int i=0;i<R;i++)
for (int j = 0; j < C; j++)
if(BRIDGES_TO_BUILD[i][j] == 0)
continue;
if (BRIDGES_TO_BUILD[out[0]][out[1]] == 0)
out = new int[]i, j;
if (BRIDGES_TO_BUILD[i][j] < BRIDGES_TO_BUILD[out[0]][out[1]])
out = new int[]i, j;
if (BRIDGES_TO_BUILD[out[0]][out[1]] == 0)
return null;
return out;
@TargetApi(Build.VERSION_CODES.GINGERBREAD)
private int[][] copy(int[][] other)
int[][] out = new int[other.length][other.length == 0 ? 0 : other[0].length];
for(int r=0;r<other.length;r++)
out[r] = Arrays.copyOf(other[r], other[r].length);
return out;
public void connect(int r0, int c0, int r1, int c1)
if(r0 == r1 && c0 > c1)
connect(r0, c1, r1, c0);
return;
if(c0 == c1 && r0 > r1)
connect(r1, c0, r0, c1);
return;
if(!canBuildBridge(r0, c0, r1, c1))
return;
BRIDGES_TO_BUILD[r0][c0]--;
BRIDGES_TO_BUILD[r1][c1]--;
if(r0 == r1)
for (int i = c0; i <= c1 ; i++)
if(IS_ISLAND[r0][i])
continue;
BRIDGES_ALREADY_BUILT[r0][i] = Direction.EAST;
if(c0 == c1)
for (int i = r0; i <= r1 ; i++)
if(IS_ISLAND[i][c0])
continue;
BRIDGES_ALREADY_BUILT[i][c0] = Direction.NORTH;
【问题讨论】：
您需要更好地尝试调试自己。在发布此问题之前，您甚至没有在上一个问题（您现在已删除）之前给它 10 分钟...找出为什么int[] tmp = state.nextIsland(row,column,dir); nextState.connect(row,column, tmp[0], tmp[1]); 什么都不返回
@IsThisjavascript 花了很多时间调试算法，我觉得我在这里绕圈子，该算法适用于第一次搜索然后尝试回溯和堆栈size = 0，@987654331 @ 这是回溯的循环。
如需快速高效的帮助，请发帖minimal reproducible example。我无法调试（太）长的代码而不运行它。
很难跟踪您的搜索试图找到的内容，但无论它是什么，您确定它会一直存在吗？因为正确的 DFS 回溯过去初始状态的含义是搜索失败。
通过堆栈以迭代方式实现 DFS 的标准方法从创建最初仅包含起始节点的堆栈开始。然后，在每次迭代中，从堆栈中弹出顶部元素，并测试它是否是您要查找的元素。如果是这样，则退出循环。如果没有，那么你推送 all 你想要从当前节点遍历的后继节点。如果在任何迭代中都没有要弹出的节点，那么搜索已经用尽了所有节点，但没有找到满足您条件的节点；这通常不是硬错误。
【参考方案1】：
您的问题的一部分对我来说是问题的根源：“我在这里缺少什么”？单元测试，除非我只是在你的项目中没有看到它们。
诸如“用户每次开始游戏时数组都会生成随机整数，这会导致算法刹车吗？”之类的问题，是单元测试存在的原因，以及以下问题：
-
在对未结束的代码部分编写测试的过程中
成为问题，你会明确地证明他们不是
问题。
如果您正在使用的代码无法按原样进行测试，或者
测试“太复杂”，重写它会让你变得更好
设计师并且经常会导致“我不敢相信我没有看到那个”
时刻。
当您重构此程序（降低复杂性、重命名变量以使其更易于理解等）时，如果出现问题，您会立即收到通知
而且您不必再花一个周末来弄清楚。
例如，不是在搜索它的方法中随机化棋盘，而是在其他地方随机化，然后将其作为参数放入该方法（或放入类的构造函数）。这样，您可以使用您自己提供的值初始化您自己的测试板，并查看某些板是否比其他板工作得更好以及为什么。将较大的方法拆分为较小的方法，每个方法都有自己的参数和测试。旨在用较小的已确认工作的部分制作程序，而不是制作一个巨大的东西然后想知道问题是您认为的小部分还是其他什么。
从长远来看，您将节省大量时间和挫败感，并且您最终将领先于那些花费数小时编码然后调试数小时的人。
【讨论】：
【参考方案2】：代码中有很多内容，但我注意到的第一件事可能会有所帮助：
// if the node can no longer be expanded, we need to backtrack
if(ds.isEmpty())
gameTree.pop();
remainingOptions.remove(new Point(row,column));
System.out.println("going back to previous decision");
continue;
你从堆栈中弹出，并继续下一个 while(true) 迭代，此时堆栈上可能没有任何内容，因为你没有添加任何其他内容。
【讨论】：
栈的值为1时如何保证不弹出？【参考方案3】：我同意@Rosa -
EmptyStackException 应该在删除或查找空堆栈时发生-
======代码中的迭代/状态 ======
**if(ds.isEmpty())** //HashMap isEmpty = true and gameTree.size() = 1
gameTree.pop(); // After removing element gameTree.size() = 0 (no elements in stack to peek or pop)
remainingOptions.remove(new Point(row,column));
System.out.println("going back to previous decision");
continue; //Skip all the instruction below this, continue to next iteration
========下一次迭代=========
while(true)
AddBridges state = gameTree.peek(); // gameTree.size() = 0 and a peek
操作将失败，程序将返回 EmptyStackException。
必需的 isEmpty 检查 -
if(gameTree.isEmpty())
System.out.println("no valid configuration found");
return;
AddBridges state = gameTree.peek();
因为，除了while循环之外，函数没有执行任何操作。如果要处理其他指令，则需要“中断”。
【讨论】：
我陷入了一个无限循环，它得到相同的值并试图重新建立桥梁以上是关于EmptyStackException - 二维数组上的 Java 深度优先搜索算法的主要内容，如果未能解决你的问题，请参考以下文章