迷宫不工作？

Question

代码：
数组是我做的预定义的布尔数组，而val是数组的长度（它是一个正方形）。我用它作为一个起点，而不是使用一个随机值

 import java.util.*; 
    import javax.swing.*; 
    public class Main 

{

public void main() 
{ 

String Val = JOptionPane.showInputDialog("Enter the number of rows/columns"); 
int x = Integer.parseInt(Val); 

boolean mazeArch[][] = new boolean [x][x]; 
BoundariesDeclared(mazeArch, x); 

generateMaze(mazeArch, x); 
convertArray(mazeArch, x); 

}

public void printArray(String Array[][]) // Prints out the array 

{

 for (int i =0; i < Array.length; i++) { 
      for (int j = 0; j < Array.length; j++) { 
     System.out.print(" " + Array[i][j]); 
    } 
    System.out.println(""); 
} 

}

public void convertArray(boolean Array[][], int z) 

{

String RealArray[][] = new String [z][z]; 
for(int x = 0; x < Array.length; x++) 
{ 
    for(int y = 0; y < Array.length; y++) 
    { 
     if(Array[x][y] == true) 
     { 
      RealArray[x][y] = "*"; 
     } 
     if(Array[x][y] == false) 
     { 
      RealArray[x][y] = " "; 
     } 
    } 
} 
printArray(RealArray); 

}

public void BoundariesDeclared(boolean Array[][], int y) 

{

for(int x = 0; x < Array.length; x++) 
    Array[0][x] = true; 
for (int x = 0; x < Array.length; x++) 
    Array[x][0] = true;  
for (int x = 0; x < Array.length; x++) 
    Array[x][Array.length-1] = true; 
for (int x = 0; x < Array.length; x++) 
    Array[Array.length-1][x] = true; 

}

public void generateMaze(boolean Array[][], int val) 

{

Stack<Integer> StackX = new Stack<Integer>(); 
Stack<Integer> StackY = new Stack<Integer>(); 
int x = val/2; // Start in the middle 
int y = val/2; // Start in the middle 
StackX.push(x); 
StackY.push(y); 

while(!StackX.isEmpty()) 
{ 
    Array[x][y] = true; // is Visited 
    x = StackX.peek(); 
    y = StackY.peek(); 

    if(Array[x][y+1] == false) 
    { 
     StackX.push(x); 
     StackY.push(y+1); 
     y = y + 1; 
    } 
    else if(Array[x][y-1] == false) 
    { 
     StackX.push(x); 
     StackY.push(y-1); 
     y = y - 1; 
    } 
    else if(Array[x+1][y] == false) 
    { 
     StackX.push(x+1); 
     StackY.push(y); 
     x = x+1; 
    } 
    else if(Array[x-1][y] == false) 
    { 
     StackX.push(x-1); 
     StackY.push(y); 
     x = x-1; 
    } 
    else 
    { 
     StackX.pop(); 
     StackY.pop(); 
    } 
} 

}}

每当我打印结果，我只得到星，这意味着，每一个布尔值设置为true。我明白我的错误，因为我访问的每一个地方的结果都是他们都设置为真。但是，我能做些什么来解决这个问题？我认为我有正确的概念，而不是应用程序。我以前问过这个问题，并被告知我需要制作两个阵列（1个用于墙壁，另一个用于访问），但我怎样才能应用这个呢？

Answer 1

你没有提到你想做什么。所以我们没有太多的帮助。

• 这个迷宫在做什么？
• 您的意见是什么？
• 您的预期成果是什么？

添加此行并调试自己。

public void generateMaze(boolean Array[][], int val) { 
     Stack<Integer> StackX = new Stack<Integer>(); 
     Stack<Integer> StackY = new Stack<Integer>(); 
     int x = val/2; // Start in the middle 
     int y = val/2; // Start in the middle 
     StackX.push(x); 
     StackY.push(y); 

     while (!StackX.isEmpty()) { 
      Array[x][y] = true; // is Visited 
      x = StackX.peek(); 
      y = StackY.peek(); 

      if (Array[x][y + 1] == false) { 
       StackX.push(x); 
       StackY.push(y + 1); 
       y = y + 1; 
      } else if (Array[x][y - 1] == false) { 
       StackX.push(x); 
       StackY.push(y - 1); 
       y = y - 1; 
      } else if (Array[x + 1][y] == false) { 
       StackX.push(x + 1); 
       StackY.push(y); 
       x = x + 1; 
      } else if (Array[x - 1][y] == false) { 
       StackX.push(x - 1); 
       StackY.push(y); 
       x = x - 1; 
      } else { 
       StackX.pop(); 
       StackY.pop(); 
      } 
      convertArray(Array, val); // add this line 
     } 
    } 

Answer 2

的解决方案仍然是一样的，当你最后一次发布了这个问题 - 你需要有两个数组

酮，对于在迷宫的每个地方，是一堵墙是真的 - 迷宫的瓷砖

酮启动全是假的 - 求解的瓷砖

求解器可以移动到只有两个数组都是假的，在这一点上一片瓦，而第二阵列（求解的瓷砖）设置为true而留下第一阵列（迷宫的瓷砖）。

Answer 3

这不是一个'编码'错误，说。你根本不知道你想要什么样的行为。尝试评论你生成迷宫的路线。以6作为参数运行你的程序。你得到：

* * * * * * 
*   * 
*   * 
*   * 
*   * 
* * * * * * 

这是什么样的迷宫？出口在哪里？再次，这不是一个编码问题，这是一个设计缺陷。当然，如果你在这个迷宫的范围内开始，你将访问所有的广场！

Answer 4

我不清楚你对输出的期望是什么，但我可以看到问题出在哪里。在你的generateMaze()方法中，你像螺旋模式一样旅行，最终触及每个节点。就像假设你有5x5阵列一样，你会像（边界已经是真的）[2,2] - > [2,3] - > [3,3] - > [3,2] - > [3， 1] - >并[2,1] - > [1,1] - >并[1,2] - > [1,3]

从中间开始，在开始访问并轮流就在你发现已经是真的（边界或访问）之前，它覆盖了所有的节点