Tiles touching all of same color check

Question

I'm currently having a problem that has stopped my productivity for quite a while. I need to check if all tiles of a color is touching each other for each color like this:
I have all my code for moving the tiles around and switching levels, but i can't seem to work out a proper algorithm that checks if the level is complete(see image above).

The base of my code is the Tile[] that holds information about all these tiles.

The Tile class looks like this:

public class Tile {
int x = 0;
int y = 0;
int type = 0;
boolean checked = false;

//SETTERS AND GETTERS FOR ALL VALUES
public void setX(int v){
    x = v;
}
public int getX(){
    return x;
}
public void setY(int v){
    y = v;
}
public int getY(){
    return y;
}
public void setType(int v){
    type = v;
}
public int getType(){
    return type;
}
public void setChecked(boolean v){
    checked = v;
}
public boolean getChecked(){
    return checked;
}
}

The "type" is the color of the tile.
Should mention that the Tile[]'s length is 25 and that each tile has got a X & Y from 0-4.
I need something that can return me a boolean[] finishedColors so i can check if it's done.

All kinds of help is surely welcome!

Answer 1

Essentially a series of flood fills - one for each cell in the grid, but skipping over any you've already visited, and dropping out early if you find a cell not connected to a group you've already flood-filled/gathered but of the same type as that group.

Written blind, so please excuse any code typos or holes; highlight them in a comment and I will amend. Also assuming a 2D array storing tiles, width and height variables detailing dimensions. With this algorithm, you don't need a Tile class at all - just a 2D array of ints would do just fine.

int IndexFromXY(int x, int y)
{
    return (y * width) + x;
}

void GatherConnectedTilesOfType(int type, int x, int y, List<int> visitedTiles)
{
    if ((x < 0) || (x >= width)) { return; } //Trivial succeed when out of bounds
    if ((y < 0) || (y >= height)) { return; }

    int index = IndexFromXY(x,y);
    if (visitedTiles.Contains(index))
    {
        //We've already checked this tile, assume that if we're still iterating, it succeeded last time
        return;
    }

    if (tiles[x][y].Type == type)
    {
        visitedTiles.Add(index);

        //Check adjacent tiles
        GatherConnectedTilesOfType(type, x+1, y, visitedTiles);
        GatherConnectedTilesOfType(type, x, y+1, visitedTiles);
        GatherConnectedTilesOfType(type, x-1, y, visitedTiles);
        GatherConnectedTilesOfType(type, x, y-1, visitedTiles);
    }
    else
    {
        //Don't proceed to adjacent tiles, this one doesn't match
    }
}

boolean IsComplete()
{
    Map<int, List<int>> connectedTiles = new HashMap<int, List<int>>();
    for (int x = 0; x < width; ++x)
    {
        for (int y = 0; y < height; ++y)
        {
            int type = tiles[x][y].Type;
            if (connectedTiles.containsKey(type))
            {
                //We've already found at least one contiguous segment of this type,
                // so if this tile isn't in that segment, the type has more than
                // one segment of that type
                int index = IndexFromXY(x,y);

                List<int> connectedTilesOfThisType = connectedTiles.get(type);
                if (!connectedTilesOfThisType.contains(index))
                {
                    return false; //More than one contiguous segment with this type
                }
                else
                {
                    //Continue on - we've already covered this cell in a Gather
                }
            }
            else
            {
                List<int> connectedTilesOfThisType = new ArrayList<int>();
                GatherConnectedTilesOfType(type, x, y, connectedTilesOfThisType);

                connectedTiles.put(type, connectedTilesOfThisType);
            }
        }
    }
    //If we get this far, we only found cells which were contiguous with cells of the same colour (and connectedTiles details the various sets)
    return true; 
}