Home/ Questions/Q 8638675
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-12T10:47:51+00:00

This is not really a maze, but the idea is similar. I have this:

  • 0

This is not really a maze, but the idea is similar.

I have this:

enter image description here

The problem is where I circled in red. I need a way to get rid of rectangles that are not part of the rest of the puzzle.

I created a simple algorithm which works for a square:

The way this works is each element of the 2D array represents a vertex (graph node). Each graph node has a list of vertices it is connected to. The graph is drawn by drawing lines from each vertex to each of their connections.

private void removeDisconnectedSquare(int x, int y)
{
    GraphNode topLeft = getNodeAt(x, y);
    GraphNode topRight = getNodeAt(x + 1, y);
    GraphNode bottomLeft = getNodeAt(x, y + 1);
    GraphNode bottomRight = getNodeAt(x + 1, y + 1);

    if(topLeft != null &&
       topRight != null &&
       bottomLeft != null &&
       bottomRight != null &&
       !hasNodeToLeft(topLeft) && hasNodeToRight(topLeft) && 
       !hasNodeAbove(topLeft) && hasNodeBelow(topLeft) &&
       hasNodeToLeft(topRight) && !hasNodeToRight(topRight) && 
       !hasNodeAbove(topRight) && hasNodeBelow(topRight) &&
       !hasNodeToLeft(bottomLeft) && hasNodeToRight(bottomLeft) && 
       hasNodeAbove(bottomLeft) && !hasNodeBelow(bottomLeft) &&
       hasNodeToLeft(bottomRight) && !hasNodeToRight(bottomRight) && 
       hasNodeAbove(bottomRight) && !hasNodeBelow(bottomRight))
    {
        removeVertex(x, y);
        removeVertex(x + 1, y);
        removeVertex(x,  y + 1);
        removeVertex(x + 1, y + 1);
    }
}

Is there an algorithm or way I could detect if a path of verticies is not part of the big connected path of verticies? Sometimes this produces a small path.

Thanks

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    I would recommend finding a good graph library. Then, represent each square as a node, and have an edge between squares if a direct path is open between them. Finally use a ‘connected nodes’ algorithm (provided by the graph library) starting from your ‘entrance node’. Finally, you can loop over all nodes that aren’t marked by the connectivity algorithm and deal with them appropriately.

    For example, if you were in C++, you could use the Boost Graph Library Connected Components algorithm. Other good graph libraries should have similar support.

    You could also roll-your-own version of such an algorithm; e.g., push unmarked neighbor nodes on a stack, mark the visited node, then pop a node off the stack until done. However, having a good graph library will be useful for other problems you’re likely to encounter in this sort of project, and IMO is preferable to rolling your own.

    It might also be worth noting that you could potentially change your maze generation algorithm to always generate a connected graph, thus preventing the need to clean up disconnected components after the fact.

    • 0