Algoritmi - Non so che titolo dare a questo thread...

Il codice non riesco a leggerlo, ti dico che con la matrice di adiacenza puoi di sicuro combinare qualcosa, anche se probabilmente qui non serve.
La matrice di adiacenza si usa quando vuoi rispondere in modo rapido alla domanda "il nodo X e Y sono connessi?".
Inoltre si usano di solito solo quando il grafo ha un numero di nodi prefissato, altrimenti devi aumentarne la dimensione, copiare tutto ecc... nel caso di grafi dinamici si usa infatti la lista di adiacenza di solito.

Detto questo, non ti serve a molto la matrice di adiacenza perché dovresti costruirla, ma per costruirla devi definire un concetto di connessione sulla tua griglia, e inizialmente questo sarà: ogni cella ha come vicini quelli che stanno sopra sotto, a sinistra a destra (o una cosa simile).
Quindi verrebbe fuori una matrice di adiacenza abbastanza scontata.
Ti consiglio invece di capire l'algoritmo per trovare le componenti connesse e dopo applicarlo direttamente sulla griglia, senza costruire esplicitamente il grafo associato: alla fine è esattamente quello che ti ha descritto Roby.

P.S.

            printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );

No.

Aldo qui si cerca solo di aiutarti, non ti additeremo come quello che non sa creare funzioni ricorsive, siamo qui tutti per migliorare.
Detto questo è giusto che tu ti metta nella condizione di apprendere questa tecnica al meglio, magari tentando di riscrivere funzioni che normalmente verrebbero implementate iterativamente con un approccio ricorsivo.
Passiamo ora al tuo codice, sinceramente non riesco a capirlo, ho anche provato a compilarlo ma il risultato non mi ha convinto. Ho provato a dare una mia interpretazione.

#define H 10//numero di righe
#define W 10//numero di colonne


int n;
bool v[H][W];//matrice che indica se una casella è stata visitata
int m[H][W];//matrice che contiene i "colori" delle celle

int rec(int m[H][W], bool v[H][W], int i, int j, int* n)
{
	v[i][j] = true;//imposto la casella corrente come visitata
	(*n)++;//Aumento il contatore delle caselle simili

	//eseguo la ricerca nelle 4 direzioni verificando se:
	//primo, la casella esista (problema dei bordi)
	//secondo, la casella non sia già stata visitata
	//terzo, la casella sia dello stesso colore
	//se le tre richieste sono soddisfatto riapplico il metodo corrente alla prossima cella(da ogni iterazione possono partire da 0 a 4 nuove iterazioni
	if (i - 1 != 0 && v[i - 1][j] == false && m[i - 1][j] == m[i][j]) rec(m, v, i - 1, j, n);
	if (j - 1 != 0 && v[i][j - 1] == false && m[i][j - 1] == m[i][j]) rec(m, v, i, j - 1, n);
	if (i + 1 != H && v[i + 1][j] == false && m[i + 1][j] == m[i][j]) rec(m, v, i + 1, j, n);
	if (j + 1 != W && v[i][j + 1] == false && m[i][j + 1] == m[i][j]) rec(m, v, i, j + 1, n);
}

//esempio sulla casella (5,5)
n = 0;
rec(m, v, 5, 5, &n);
printf("%d", n);

Spero che questo esempio possa aiutarti a capire una generica implementazione ricorsiva.

Nel frattempo, non avendo ancora letto la tua ultima risposta, ho messo insieme una inutility che disegna matrici d'adiacenza secondo i criteri che dicevi: sono adiacenti le caselle dello stesso colore sopra, sotto, a destra o a sinistra. L'inutility crea matrici da tabelle a tre colori fino a un massimo di 26*26 caselle, in effetti allocando tutto dinamicamente, quindi le traspone graficamente in un file in formato svg. Esempio (file generato dal programma) in allegato.

Certo hai ragione a definire "scontate" le tabelle di quel tipo, DAL TUO PUNTO DI VISTA. Il mio punto di vista è molto più raso-terra, per cui penso che proprio soffermarmi per un po' sulle cose più semplici potrebbe aiutarmi a comprendere qualcosa (forse).

L'algoritmo che mi ha suggerito Roby l'ho capito, infatti è la prima cosa che m'è venuta in mente anche in autonomia, solo che non sono riuscito a trasformarlo in qualcosa di funzionante sul lato codice perché mi si grippa tutto nel cranio. Insisterò.

P.S. quanto meno le matrici di adiacenza che butta fuori la mia inutilty potrebbero andare bene come schemi per qualche lavoretto astratto a punto croce.

EDIT: Nel frattempo, Roby, è arrivata la tua risposta che, a colpo d'occhio, non mi dice niente. Ora mia metto lì e cerco di capirla. Forza e coraggio! (l'incoraggiamento me lo rivolgo da solo, porca pupazza!)

Non allega... ci riprovo qui.

EDIT: Forse ho capito... che non "prenda" i file svg? Provo con zip.

è esattamente l'algoritmo che ti ho proposto a parole nei post precedenti, prova a confrontare le due cose e se hai dubbi chiedi, siamo qui per questo

Roby, con il metodo che mi hai suggerito, se l'ho capito bene, metti in relazione le caselle dello stesso colore che sono in contatto tra loro, il che va benissimo. Non ho capito, però, com'è che fai a scoprire le varie aree oltre alla prima, quelle che non sono collegate alla prima (magari perché sono di un altro colore, o perché sono dello stesso colore ma in una zona diversa del diagramma).

Forse che semplicemente riavvi la ricorsione a partire dalla prima casella "non visitata" che trovi?

Io non avevo idea di come sarebbe stato applicato l'algoritmo, questa è un implementazione generica che calcola il numero di caselle congruenti con una di partenza. Poi sta a te creare un implementazione specifica per il tuo problema. Comunque se vedi la funzione elimina in automatico le caselle già visitate, quindi se volessi controllare l'intera mappa per ottenere tutte le zone con relative dimensioni ti basterebbe applicare la funzione ad ogni singola casella della griglia (ovviamente bloccando il processo per ogni casella gia visitata).

Sì, come immaginavo. Poi bisogna vedere se riuscirò a passare dall'aver compreso la questione di concetto al renderla praticamente operativa. Oggi no. Ci proverò domani, dopo avere distolto per un po' la testa da queste cose.

Ovviamente, un grazie grosso come una casa.