[JAVA] Esercizio con matrice di boolean

[Javino89]

Allora, sono davanti ad un bel problema di programmazione
Il discorso è abbastanza semplice. Ho una matrice di boolean che mi rappresenta una TOPOGRAFIA. In particolare
le celle FALSE mi indicano area di ACQUA, e le celle TRUE mi indicano area di TERRA. I bordi per semplicità
sono tutta acqua.

Avendo questa topografia, devo risolvere questi tre problemi:

1) Calcolare quante isole ci sono nella topografia

Note: Una isola e' un'area costituita solamente
da celle contigue di terra. Ciascuna isola puo' contenere al suo interno
ulteriori aree di acqua (laghi interni), all'interno dei quali e' possibile che si
siano a loro volta altre isole.

2) Calcolare tra le spiagge, qual'è quella più ampia

Note: La spiaggia, in un'isola, e' un'area costituita solamente da celle contigue di terra
che confinano con almeno un'area d'acqua. Attenzione: un'isola puo' avere piu' spiagge
non contigue: ad esempio una isola con un lago interno avra' una spiaggia
connante con il mare e una connante con il lago e che vanno considerate
come due spiagge dierenti anche se aeriscono alla stessa isola.

3) Contare i secoli necessari ad inondare tutta la topografia

Note: Ogni secolo, a causa dell'innalzamento del livello del mare, tutte celle che sono
spiagge vengono inondate e sostituite quindi dall'acqua. Il metodo calcola il
numero minimo di secoli necessari ad inondare tutte le aree emerse.

Ora chiedere aiuto per tutto mi pare esagerato, inizio con chiedere aiuto con il problema 3) che è il più
semplice a mio parere. L'idea che ho adottato è: ad ogni iterazione fai diventare false (acqua) le celle di terra (true)
che sono spiagge (che confinano con almeno un area false), restituisci il numero di iterazioni.

Il problema è che il codice che sto per allegare itera una volta sola a quanto ho capito:

    public int secoliInondazione(boolean[][] topografia)
    {
        boolean[][] copia = this.copia(topografia);
        int ris = 0;
        while(!tuttaAcqua(copia))
        {
            for(int i=0; i<copia.length; i++)
            {
                for(int j=0; j<copia[0].length; j++)
                {
                    if(copia[i][j] == true)                   //Se hai incontrato un'area di terra..
                    {
                        if(isParteSpiaggia(copia,i,j))   //Verifica se è spiaggia
                        {
                            copia[i][j] = false;              //In tal caso falla diventare acqua
                        }
                    }
                }
            }
            ris = ris + 1;                                   //Un secolo è passato.. ricomincia con re-iterare la matrice
        }
        return ris;
    }
    private boolean[] confini(boolean[][]topografia,int i,int j)
    {
        boolean uno = topografia[i-1][j-1];
        boolean due = topografia[i-1][j];
        boolean tre = topografia[i-1][j+1];
        boolean quattro = topografia[i][j-1];
        boolean cinque = topografia[i][j+1];
        boolean sei = topografia[i+1][j-1];
        boolean sette = topografia[i+1][j];
        boolean otto = topografia[i+1][j+1];
        boolean[]arr = {uno,due,tre,quattro,cinque,sei,sette,otto};
        return arr;
    }
    private boolean isParteSpiaggia(boolean[][]topografia,int i,int j)
    {
        boolean[]arr = this.confini(topografia, i, j);
        int cont = 0;
        for(int x=0; x<arr.length; x++)
        {
            if(arr[x] == false)
            {
                cont++;
            }
        }
        if(cont == 1)
        {
            return true;
        }
        else if(cont > 1)
        {
            return true;
        }
        else
            return false;
    }

    private boolean tuttaAcqua(boolean[][]topografia)
    {
        for(int i=0; i<topografia.length; i++)
        {
            for(int j=0; j<topografia[0].length; j++)
            {
                if(topografia[i][j] == true)
                {
                    return false;
                }
            }
        }
        return true;
    }

    private boolean[][] copia(boolean[][]topografia)
    {
        boolean[][] ris = new boolean[topografia.length][topografia[0].length];
        for(int i=0; i<topografia.length; i++)
        {
            for(int j=0; j<topografia[0].length; j++)
            {
                ris[i][j] = topografia[i][j];
            }
        }
        return ris;
    }

[Javino89]

up