Il codice che ho scritto è questo, dopo l'inserimento di una griglia di valori esempio
1 2 1 2
3 4 5 6
1 3 9 8
7 2 7 6

devo implementare delle tecniche per risolvere un gioco che si chiama Hitori
la griglia è sempre quadrata di varie dimensioni
La funzione panino imbottito implementa una tecnica ma dopo che ho scoperto al primo passo che il 2 nella posizione (0,1) non va annerito, dovrebbe trovare i 2 sulla stessa riga e colonna in modo da annerirli.

Suggerimenti!!!!
codice:
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

typedef int** TMatrice; /* tipo matrice,  vettore di puntatori */

/*============================ Dichiarazione delle funzioni (prototipi) ===============================*/

TMatrice alloca_matrice(int n);                         /* Alloca memoria per una matrice */
void libera_matrice(TMatrice *matrice, int n);          /* Libera la memoria allocata */
void inserimento(TMatrice matrice, int n);
void stampa_matrice (TMatrice matrice , int n);
void panino_imbottitorighe(TMatrice matrice, int n);
void panino_imbottitocolonne(TMatrice matrice, int n);

/*=====================================================================================================*/

/*==================== MAIN ===================== */

int main()
{
  TMatrice matrice;
  int n;

  printf("Dimensione griglia?\n");
  scanf("%d" , &n);

  matrice = alloca_matrice(n);
 
  inserimento(matrice, n);

  panino_imbottitorighe(matrice,n);
  panino_imbottitocolonne(matrice,n);

  printf("\n");
  stampa_matrice(matrice, n);
 
  libera_matrice(&matrice, n);
  return 0;
}


/*
  Alloca la memoria per una matrice di dimensione n e ne restituisce
  un puntatore.
 */
TMatrice alloca_matrice(int n)
{
  TMatrice matrice;
  int i;

  /* alloco il vettore delle righe. Ogni elemento di questo vettore è un puntatore */
  if(!(matrice = (TMatrice) malloc (n * sizeof(int *)))) {
       fprintf(stderr,"Errore di allocazione per la matrice\n");
      return 0;
   }

 /* per ogni riga alloco le colonne */
  for (i=0; i<n; i++) {
    if(!(matrice[i] = (int *) malloc (n * sizeof(int)))) {
      fprintf(stderr,"Errore di allocazione per la i-esima posizione \"%d\"\n",i);
      return 0;
      }
   }
  return matrice;
}


/*  Libera la memoria allocata da alloca_matrice */
void libera_matrice(TMatrice *matrice, int n)
{
  int i;

  for (i=0; i<n; i++)
    free((*matrice)[i]);
  free(*matrice);
}

/* Inserimento dei valori all'interno della matrice*/
void inserimento(TMatrice matrice, int n){
 
 int i,j;
 
 for(i=0 ; i<n ; i++)
   for(j=0 ; j<n ; j++)
     {
       scanf("%d",&matrice[i][j]);
     }
 printf("\n");
}

/* stampa del risultato della matrice */
/* in realtà alla fine dovrà stampare la metrice con degli zero che corrispondono alle caselle annerite*/
void stampa_matrice(TMatrice matrice, int n){

  int i,j;

  for (i=0;i<n;i++)
    {
      for (j=0;j<n;j++)
   printf("%d ", matrice[i][j]);
      printf("\n");
    }
}

/*===================== implementazione dell tecniche di risoluzione ================*/
/* numero non annerito = -1- */
/* numero annerito = *1*     */
/* numero che non si sa ancora se annerito o no = 1 */




/* [PI]  PANINO IMBOTIITO*/

void panino_imbottitorighe(TMatrice matrice, int n) {

  int i,j;
  for (i=0; i<n; i++)
          for(j=0; (j+2)<n; j++)
      if(matrice[i][j] == matrice[i][j+2]) /* controlla se i valori inseriti sono uguali sulle righe*/   
   printf("%s%d%s%d%s", "no (" , i , ", " ,  j+1,") : PI\n");           
}


void panino_imbottitocolonne(TMatrice matrice, int n){

  int i,j;
  for(j=0; j<n; j++)
       for(i=0;(i+2)<n;i++)
      if(matrice[i][j] == matrice[i+2][j]) /* controlla se i valori inseriti sono uguali sulle colonne*/   
         printf("%s%d%s%d%s", "no (" , i+1 , ", " ,  j,") : PI\n");
}