Trovare gli stessi numeri in una matrice

Ho una domanda qui e sto cercando di trovare una soluzione. Ma voglio vedere anche altre opinioni.

Il problema è il seguente:

There is a matrix NxN which holds integer numbers. You should count all the different numbers in the matrix with the following conditions:

• If two-or-more same numbers are adjacent (left, right, above, below) each of other it counts as one.

Esempio di matrice:

1 2 3 4

1 1 2 4

5 6 2 2

Quindi per l'esempio sopra ci sono: 7 numeri diversi perché nella posizione della matrice: [1,1] [2,1] [2,2] ci sono 1 che ha la condizione del problema vero perciò questi 3 i numeri contano come uno, in posizione [1,4] [2,4] ci sono 4 quindi conta come uno pure, e infine in posizioni [2,3], [3,3] e [3,4] ci sono 3s quindi conta come un numero.

Il mio pensiero è di impostare i numeri duplicati su negativi e quindi contare solo i positivi, ma non sono sicuro che ciò funzionerà per tutti i casi inclusi e per i casi d'angolo.

Il mio codice:

public class matrix
{
   public static void main(String[] args)
   {
      int[][] arr = 
      { 
          {1, 2, 3, 4}, 
          {1, 1, 2, 4},
          {5, 6, 2, 2},
      };

      for(int row = 0; row < arr.length; ++row)
      {
         for(int col = 0; col < arr[row].length; ++col)
         {
            //top
            if(row!=0)
            {
               if((arr[row][col] == arr[row-1][col]) || (Math.abs(arr[row][col]) == arr[row-1][col]) || (arr[row][col] == Math.abs(arr[row-1][col])))
               {
                  arr[row-1][col] = -arr[row-1][col];
               }
            }

            //botom
            if(row!=arr.length-1)
            {
               if(arr[row][col] == arr[row+1][col] || Math.abs(arr[row][col]) == arr[row+1][col] || arr[row][col] == Math.abs(arr[row+1][col]))
               {
                  arr[row+1][col] = -arr[row+1][col];
               }
            }

            //left
            if(col!=0)
            {
               if(arr[row][col] == arr[row][col-1] || Math.abs(arr[row][col]) == arr[row][col-1] || arr[row][col] == Math.abs(arr[row][col-1]))
               {
                  arr[row][col-1] = -arr[row][col-1];
               }
            }

            //right
            if(col!=arr[0].length-1)
            {
               if(arr[row][col] == arr[row][col+1] || Math.abs(arr[row][col]) == arr[row][col+1] || arr[row][col] == Math.abs(arr[row][col+1]))
               {
                  arr[row][col+1] = -arr[row][col+1];
               }
            }
         }
      }


      for(int row = 0; row < arr.length; ++row)
      {
         for(int col = 0; col < arr[row].length; ++col)
         {
            System.out.print(arr[row][col] + " ");
         }

         System.out.println();
      }
   }
}

Risultato previsto:

 1  2  3  4

-1 -1  2 -4

 5  6 -2 -2

Risultato del codice:

 1  2  3 -4

 1 -1 -2 -4

 5  6  2 -2