Question

First of all: this is not a homework assignment, it’s for a hobby project of mine.

Background:
For my Java puzzle game I use a very simple recursive algorithm to check if certain spaces on the ‘map’ have become isolated after a piece is placed. Isolated in this case means: where no pieces can be placed in.

Current Algorithm:

public int isolatedSpace(Tile currentTile, int currentSpace){
        if(currentTile != null){
            if(currentTile.isOpen()){
                currentTile.flag(); // mark as visited
                currentSpace += 1;
                currentSpace = isolatedSpace(currentTile.rightNeighbor(),currentSpace);
                currentSpace = isolatedSpace(currentTile.underNeighbor(),currentSpace);
                currentSpace = isolatedSpace(currentTile.leftNeighbor(),currentSpace);
                currentSpace = isolatedSpace(currentTile.upperNeighbor(),currentSpace);
                if(currentSpace < 3){currentTile.markAsIsolated();} // <-- the problem
            }
        }
        return currentSpace;
    }

This piece of code returns the size of the empty space where the starting tile is part of. That part of the code works as intented. But I came across a problem regarding the marking of the tiles and that is what makes the title of this question relevant 😉

The problem:
The problem is that certain tiles are never ‘revisited’ (they return a value and terminate, so never get a return value themselves from a later incarnation to update the size of the empty space). These ‘forgotten’ tiles can be part of a large space but still marked as isolated because they were visited at the beginning of the process when currentSpace had a low value.

Question:
How to improve this code so it sets the correct value to the tiles without too much overhead? I can think of ugly solutions like revisiting all flagged tiles and if they have the proper value check if the neighbors have the same value, if not update etc. But I’m sure there are brilliant people here on Stack Overflow with much better ideas 😉

---

Update:
I’ve made some changes.

public int isolatedSpace(Tile currentTile, int currentSpace, LinkedList<Tile> visitedTiles){
        if(currentTile != null){
            if(currentTile.isOpen()){
                // do the same as before
                visitedTiles.add(); 
            }
        }
        return currentSpace;
    }

And the marktiles function (only called when the returned spacesize is smaller than a given value)

marktiles(visitedTiles){
       for(Tile t : visitedTiles){
            t.markAsIsolated();
       }
}

This approach is in line with the answer of Rex Kerr, at least if I understood his idea.

Answer 1

You need to have a two-step process: gathering info about whether a space is isolated, and then then marking as isolated separately. So you’ll need to first count up all the spaces (using one recursive function) and then mark all connected spaces if the criterion passes (using a different recursive function).