[C] Modificare valore all'interno di una matrice

[garfa]

si avevo già trovato una soluzione del genere:

void angolo(CELLA** matrice , int n){

  if(matrice[0][1].marcatura == 2)  /* CASO 1 */
    non_annerire_a(matrice,n,1,0);
       if(matrice[1][0].marcatura == 2)  /* CASO 2 */
    non_annerire_a(matrice,n,0,1);
       if(matrice[n-2][0].marcatura == 2)  /* CASO 3 */
    non_annerire_a(matrice,n,n-1,1);
       if(matrice[n-1][1].marcatura == 2)  /* CASO 4 */
    non_annerire_a(matrice,n,n-2,0);
       if(matrice[0][n-2].marcatura == 2)  /* CASO 5 */
    non_annerire_a(matrice,n,1,n-1);
       if(matrice[1][n-1].marcatura == 2)  /* CASO 6 */
    non_annerire_a(matrice,n,0,n-1);
       if(matrice[n-2][n-1].marcatura == 2)  /* CASO 7 */
    non_annerire_a(matrice,n,n-1,n-2);
       if(matrice[n-1][n-2].marcatura == 2)  /* CASO 8 */
    non_annerire_a(matrice,n,n-2,n-1);
}

così pare funzionare!!!!
per il Nero impossibile e Bianco impossibile??? hai qualche idea
grazie per i suggerimenti!!!

[garfa]

Come potrei fare per implementare le 2 regole che controllano per assurdo se una casella annerita/non annerita , dopo aver applicato le altre tecniche SB e NV e aver visto che viola le proprietà del gioco in realtà non può essere annerita/non annerita ?????

[cionci]

Originariamente inviato da garfa

Come potrei fare per implementare le 2 regole che controllano per assurdo se una casella annerita/non annerita , dopo aver applicato le altre tecniche SB e NV e aver visto che viola le proprietà del gioco in realtà non può essere annerita/non annerita ?????

Non l'ho capita

PercHé nel codice sopra tieni conto di matrice[0][1] e non di matrice[i][j] ?

[garfa]

PercHé nel codice sopra tieni conto di matrice[0][1] e non di matrice[i][j] ?

Ho fatto così per tenere conto dei soli angoli..
se guardi qui : http://www.menneske.no/hitori/methods/eng/methodcc.html
se metto matrice[i][j] dovrei farlo per tutte le celle sul lato come nel metodo close edge , mentre io volevo fare corner close.

Per il metodo [NI] è così:
Se annerendo una casella e applicando ricorsivamente le tecniche SB e NV si ottiene necessariamente una configurazione che non rispetta le 3 regole, allora al casella non può essere annerita.

Esempio

no (4, 3) : A
*1* -1- *1* -2- *3*
-5- 4 -2- 3 -1-
1 -5- *3* -4- -3-
-2- *4* -4- -1- *4*
1 -2- 1 -5- -4-

da qui il passo dopo è questo

no (4, 2) : NI
*1* -1- *1* -2- *3*
-5- 4 -2- 3 -1-
1 -5- *3* -4- -3-
-2- *4* -4- -1- *4*
1 -2- -1- -5- -4-

perchè suppone che venga annerito , però se viene annerito 1 verde è non annerito ma l'1 blu è annerito e non va bene perchè si chiudono delle celle, non rispettando la regola 3 della componente connessa, quindi non andrà annerita

[garfa]

Allora quello che ho pensato per la regola [NI]:

guardo se ci sono delle celle con marcatura==0
la suppongo nera e applico le regole ricorsivamente.
nell'esempio
*1* -1- *1* -2- *2*
-5- 4 -2- 3 -1-
1 -5- *3* -4- -3-
-2- *4* -4- -1- *4*
1 -2- 1 -5- -4-

l'1 rosso lo suppongo nero allora l'1 verde deve essere bianco perchè altrimenti il 2 rimane chiuso, e l'1 blu deve essere nero per SB..ma non può esserlo perchè le tre celle rimarebbero chiuse..quindi la supposizione non va bene e l'1 rosso non è nero ma non va annerito.
il problema è la verifica della componente connessa e mantenere memoria della cella di cui si è fatta la supposizione.

si potrebbe fare con una pila ,quando verifico che le supposizione non va bene tolgo gli elementi memorizzati nella pila e in fondo troverò la marcatura bianca da assegnarli...

hai dei suggerimenti!!!scusa è un po un casino da spiegare

[garfa]

Ho dimenticato questa tecnica
TRAPEZIO:

2 3
* *
2 a
a 3

dove asterisco vuol dire qualsiasi valore, anche nessuno e "a" vuol dire che non va annerito

cioè se trovo una configurazione così i 2 valori "a" non vanno anneriti!!!
Poi mi rimane da risolvere la questione già espost prima!!!
AIUTOOOOOO

[garfa]

void trapezio(CELLA** matrice, int n){

  int i,j,a,b;
  for(i=0;i<n-2;i++)
    for(j=0;j<n-1;j++)
       for(a=i+1;a<n-1;a++)
       if(matrice[i][j].valore==matrice[a][j].valore && matrice[i][j+1].valore==matrice[a+1][j+1].valore)
	 /* richiamo non_annerire per il primo elemento */
       non_annerire_tr(matrice,n,a+1,j);
  /* richiamo non annerire per il secondo elemento */
  non_annerire_tr(matrice,n,a,j+1);  /* se inserisco questo mi dà una valore sbagliato*/
}

come faccio a richiamare non annerire per il secondo elemento sui valori giusti?

[garfa]

devo implementare una funzione che lavora su una matrice allocata dinamicamente per verificare che le celle della matrice siano collegate tra loro, senza che ci siano caselle isolate dalle altre.
Esempio:
soluzione sbagliata:
1 1 1 2 3
5 4 2 3 1
1 5 3 4 3
2 4 4 1 4
1 2 1 5 4
qui le celle non rosse sono divise in 2
i 3 numeri blu sono separati

soluzione corretta
1 1 1 2 3
5 4 2 3 1
1 5 3 4 3
2 4 4 1 4
1 2 1 5 4
tutte le celle con in numeri non rossi sono collegati

io pensavo a un grafo, avete suggerimenti?!!