Java 将ASCII迷宫转换为图形

我有一个迷宫，如下所示：

XXXOOOOX
OXXXOXOE
OXXOOXXO
OSXOXXXO
XOOOXOOO

//X = wall
//O = path
//S = startpoint
//E = endpoint

我想把它转录成一个图（邻接矩阵），但我不确定我是否要这么做。邻接矩阵是布尔值列表，true表示可走的路径，false表示不可能的路径（例如迷宫中的

（0，-1）

无法连接到

（7，-1）

（0,0是最左上方的节点））。我不知道如何转录这个，我最好的猜测是将列表中的每个元素，然后是一个带有连接节点的子列表。考虑到这个迷宫的大小，很难进行处理，因此这里有一个较小的迷宫：

X E || A B
S O || C D

上述迷宫的邻接矩阵是否在下方（1=真，0=假）

这真的很让人困惑，我不知道如何将x，y（有时也是z）坐标映射到图形上。

试试这个

 static void set(boolean[][] paths, int cols, int row0, int col0, int row1, int col1) {
     int index0 = row0 * cols + col0;
     int index1 = row1 * cols + col1;
     paths[index0][index1] = paths[index1][index0]= true;
 }

 static boolean[][] paths(String[] maze) {
     int rows = maze.length;
     int cols = maze[0].length();
     boolean[][] paths = new boolean[rows * cols][rows * cols];
     for (int i = 0; i < rows; ++i) {
         for (int j = 0; j < cols; ++j) {
             if (maze[i].charAt(j) == 'X')
                 continue;
             if (i + 1 < rows && maze[i + 1].charAt(j) != 'X')
                 set(paths, cols, i, j, i + 1, j);
             if (j + 1 < cols && maze[i].charAt(j + 1) != 'X')
                 set(paths, cols, i, j, i, j + 1);
         }
     }
     return paths;
 }

 public static void main(String[] args) {
     String[] maze = {
         "XXXOOOOX",
         "OXXXOXOE",
         "OXXOOXXO",
         "OSXOXXXO",
         "XOOOXOOO",
     };
     boolean[][] paths = paths(maze);
     for (boolean[] row : paths) {
         for (boolean cell : row)
             System.out.print(cell ? "1" : "0");
         System.out.println();
     }
 }

static void set（boolean[][]路径，int cols，int row0，int col0，int row1，int col1）{
int index0=row0*cols+col0；
int index1=row1*cols+col1；
路径[index0][index1]=路径[index1][index0]=真；
}
静态布尔[][]路径（字符串[]）{
int rows=maze.length；
int cols=maze[0]。长度（）；
布尔[][]路径=新布尔[rows*cols][rows*cols]；
对于（int i=0；i

一般方法是：对于每对（x，y）坐标，检查（x，y）和（x-1，y）是否都可以通过。如果是，请输入一个真实的。（x，y）的所有其他邻居也是如此。所有非相邻的元素默认为false。@Sirko，对于n*m维的迷宫，邻接矩阵是否应为n^2个元素宽，m^2个元素深？对于

m*n

迷宫，您将拥有

（m*n）

节点，从而生成

（m*n）*（m*n）

邻接矩阵。可能邻接列表是更好的方法，因为你的矩阵非常稀疏。@riista可能会帮助你。

 static void set(boolean[][] paths, int cols, int row0, int col0, int row1, int col1) {
     int index0 = row0 * cols + col0;
     int index1 = row1 * cols + col1;
     paths[index0][index1] = paths[index1][index0]= true;
 }

 static boolean[][] paths(String[] maze) {
     int rows = maze.length;
     int cols = maze[0].length();
     boolean[][] paths = new boolean[rows * cols][rows * cols];
     for (int i = 0; i < rows; ++i) {
         for (int j = 0; j < cols; ++j) {
             if (maze[i].charAt(j) == 'X')
                 continue;
             if (i + 1 < rows && maze[i + 1].charAt(j) != 'X')
                 set(paths, cols, i, j, i + 1, j);
             if (j + 1 < cols && maze[i].charAt(j + 1) != 'X')
                 set(paths, cols, i, j, i, j + 1);
         }
     }
     return paths;
 }

 public static void main(String[] args) {
     String[] maze = {
         "XXXOOOOX",
         "OXXXOXOE",
         "OXXOOXXO",
         "OSXOXXXO",
         "XOOOXOOO",
     };
     boolean[][] paths = paths(maze);
     for (boolean[] row : paths) {
         for (boolean cell : row)
             System.out.print(cell ? "1" : "0");
         System.out.println();
     }
 }