java生成迷宫prim,为什么我用Java实现的随机Prim's Algorithm只会生成完整的网格?

I attempted to follow this pseudocode on wikipedia https://en.wikipedia.org/wiki/Maze_generation_algorithmRandomized_Prim's_algorithm

but my code just generates a full grid. I seem to be missing something in my understanding of what the algorithm does. Can someone help explain what I'm doing wrong?

I've looked at a few sources but I can't wrap my head around it

public class MazeGen {

private int dimension, nodeCounter;

private Node[][] nodes;

private List walls;

public static void main(String[] args) {

MazeGen g = new MazeGen(20);

g.generate();

g.printMaze();

}

private void generate() {

pickCell();

generateMaze();

}

private void generateMaze() {

while (!walls.isEmpty()) {

int v;

Edge wall = walls.get(ThreadLocalRandom.current().nextInt(walls.size()));

if ((!wall.nodes[0].visited && wall.nodes[1].visited)

|| (wall.nodes[0].visited && !wall.nodes[1].visited)) {

if (!wall.nodes[0].visited)

v = 0;

else

v = 1;

includeNode(wall.nodes[v]);

wall.nodes[Math.abs(v - 1)].visited = true;

}

walls.remove(wall);

}

}

private void pickCell() {

int i = ThreadLocalRandom.current().nextInt(dimension);

int j = ThreadLocalRandom.current().nextInt(dimension);

includeNode(nodes[i][j]);

}

private void includeNode(Node node) {

node.visited = true;

node.partOfMaze = true;

walls.addAll(node.edges);

}

public void printMaze() {

for (int i = 0; i < dimension; i++) {

System.out.println();

for (int j = 0; j < dimension; j++) {

if (nodes[i][j].partOfMaze) {

System.out.print(".");

} else

System.out.print("p");

}

}

}

public MazeGen(int n) {

nodes = new Node[n][n];

walls = new ArrayList();

dimension = n;

createNodes();

connectAdjacents();

}

private void connectAdjacents() {

for (int i = 0; i < dimension; i++) {

for (int j = 0; j < dimension; j++) {

verifyConnection(i, j, i, j + 1);

verifyConnection(i, j, i + 1, j);

}

}

}

private void verifyConnection(int i, int j, int arg1, int arg2) {

if (arg1 < dimension && arg2 < dimension)

connect(i, j, arg1, arg2);

}

private void createNodes() {

for (int i = 0; i < dimension; i++) {

for (int j = 0; j < dimension; j++) {

nodes[i][j] = new Node();

}

}

}

private void connect(int row, int col, int row2, int col2) {

nodes[row][col].edges.add(new Edge(nodes[row][col], nodes[row2][col2]));

nodes[row2][col2].edges.add(new Edge(nodes[row][col], nodes[row2][col2]));

}

private class Node {

boolean visited, partOfMaze;

int number;

List edges;

Node() {

number = nodeCounter++;

edges = new ArrayList();

}

@Override

public String toString() {

return String.valueOf(number);

}

}

private class Edge {

Node[] nodes;

Edge(Node n, Node n2) {

nodes = new Node[2];

nodes[0] = n;

nodes[1] = n2;

}

@Override

public String toString() {

return nodes[0] + "-" + nodes[1];

}

}

解决方案

Forget Wikipedia, they censor free speech and manipulate information, especially in political and social areas. For that reason I also deleted all my additions to the Wikipedia page on "maze generation" (see page history).

The idea of "Prim's" MST algorithm is to maintain a "cut" (a set of edges) between disconnected subgraphs and always select the cheapest edge to connect these subgraphs. Visited vertices are marked to avoid generating cycles.

This can be used for maze generation by using edge random weights in a full grid graph or by starting with an empty grid graph and adding randomly weighted edges on the fly.

See my GitHub repository on maze generation for details:

public void createMaze(int x, int y) {

cut = new PriorityQueue<>();

expand(grid.cell(x, y));

while (!cut.isEmpty()) {

WeightedEdge minEdge = cut.poll();

int u = minEdge.either(), v = minEdge.other();

if (isCellUnvisited(u) || isCellUnvisited(v)) {

grid.addEdge(u, v);

expand(isCellUnvisited(u) ? u : v);

}

}

}

private void expand(int cell) {

grid.set(cell, COMPLETED);

grid.neighbors(cell).filter(this::isCellUnvisited).forEach(neighbor -> {

cut.add(new WeightedEdge<>(cell, neighbor, rnd.nextInt()));

});

}