javafx用prim算法生成迷宫

JavaFX 是一个用于创建富客户端应用程序的 Java 应用程序框架。Prim 算法是一种用于生成迷宫的经典算法。下面是使用 JavaFX 实现 Prim 算法生成迷宫的简单步骤：

1. 创建一个网格图形界面，用于显示迷宫。

2. 初始化一个二维数组表示迷宫的网格。

3. 从任意一个起点开始，将其加入迷宫中。

4. 将所有未加入迷宫的点与已加入迷宫的点之间的边按权值从小到大排序。

5. 遍历边，如果边所连接的两个点都未加入迷宫，将该边加入迷宫，并将新加入的点标记为已加入迷宫。

6. 重复步骤 4 和 5 直到所有点都加入迷宫为止。

下面是一个使用 JavaFX 和 Prim 算法生成迷宫的示例代码：

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.layout.GridPane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;

public class PrimMaze extends Application {

    private static final int SIZE = 20;
    private static final int CELL_SIZE = 25;

    private int[][] maze = new int[SIZE][SIZE];
    private List<Rectangle> rectangles = new ArrayList<>();

    @Override
    public void start(Stage stage) throws Exception {
        GridPane root = new GridPane();
        Scene scene = new Scene(root, SIZE * CELL_SIZE, SIZE * CELL_SIZE);

        initMaze();

        for (int i = 0; i < SIZE; i++) {
            for (int j = 0; j < SIZE; j++) {
                Rectangle rectangle = new Rectangle(CELL_SIZE, CELL_SIZE);
                rectangle.setFill(Color.WHITE);
                rectangles.add(rectangle);
                root.add(rectangle, j, i);
            }
        }

        buildMaze();

        stage.setScene(scene);
        stage.show();
    }

    private void initMaze() {
        for (int i = 0; i < SIZE; i++) {
            for (int j = 0; j < SIZE; j++) {
                maze[i][j] = 1;
            }
        }
    }

    private void buildMaze() {
        PriorityQueue<Edge> queue = new PriorityQueue<>();
        boolean[][] visited = new boolean[SIZE][SIZE];

        int startX = (int) (Math.random() * SIZE);
        int startY = (int) (Math.random() * SIZE);

        visited[startX][startY] = true;

        for (int i = 0; i < SIZE; i++) {
            for (int j = 0; j < SIZE; j++) {
                if (!visited[i][j]) {
                    queue.add(new Edge(i, j, i - 1, j));
                    queue.add(new Edge(i, j, i, j - 1));
                    queue.add(new Edge(i, j, i + 1, j));
                    queue.add(new Edge(i, j, i, j + 1));
                }
            }
        }

        while (!queue.isEmpty()) {
            Edge edge = queue.remove();

            int x1 = edge.x1;
            int y1 = edge.y1;
            int x2 = edge.x2;
            int y2 = edge.y2;

            if (visited[x1][y1] && !visited[x2][y2]) {
                visited[x2][y2] = true;
                maze[x1][y1] = 0;
                maze[x2][y2] = 0;
            }

            updateMaze();
        }
    }

    private void updateMaze() {
        for (int i = 0; i < SIZE; i++) {
            for (int j = 0; j < SIZE; j++) {
                Rectangle rectangle = rectangles.get(i * SIZE + j);

                if (maze[i][j] == 0) {
                    rectangle.setFill(Color.BLACK);
                } else {
                    rectangle.setFill(Color.WHITE);
                }
            }
        }
    }

    public static void main(String[] args) {
        launch(args);
    }

    private class Edge implements Comparable<Edge> {
        int x1, y1, x2, y2;

        public Edge(int x1, int y1, int x2, int y2) {
            this.x1 = x1;
            this.y1 = y1;
            this.x2 = x2;
            this.y2 = y2;
        }

        public double getDistance() {
            return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
        }

        @Override
        public int compareTo(Edge o) {
            return Double.compare(getDistance(), o.getDistance());
        }
    }
}

该示例代码通过 JavaFX 创建一个网格图形界面，并使用 Prim 算法生成迷宫。其中，`initMaze()` 方法用于初始化迷宫，`buildMaze()` 方法用于生成迷宫，`updateMaze()` 方法用于更新迷宫的显示。在 `Edge` 类中，`getDistance()` 方法用于计算边的权值，`compareTo()` 方法用于比较边的权值大小。