迷宮不工作？

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]

從中間開始，在開始訪問並輪流就在你發現已經是真的（邊界或訪問）之前，它覆蓋了所有的節點