Homepage  Il progetto dsy.it è l'unofficial support site dei corsi di laurea del Dipartimento di Scienze dell'Informazione e del Dipartimento di Informatica e Comunicazione della Statale di Milano. E' un servizio degli studenti per gli studenti, curato in modo no-profit da un gruppo di essi. I nostri servizi comprendono aree di discussione per ogni Corso di Laurea, un'area download per lo scambio file, una raccolta di link e un motore di ricerca, il supporto agli studenti lavoratori, il forum hosting per Professori e studenti, i blog, e molto altro...
In questa sezione è indicizzato in textonly il contenuto del nostro forum


.dsy:it. .dsy:it. Archive > Didattica > Corsi A - F > Algoritmi e strutture dati
Pages: [1] 2 
progetto Hitori
Clicca QUI per vedere il messaggio nel forum
donivl16
Ciao ragazzi apro un thread per il progetto hitori.
Cosa pensate per la struttura di dati che va utilizzata per memorizzare la griglia ?

elex1984
nessuna idea???

donivl16
boh, io sto guardando le hash map penso che siano quelle giuste ,anke se nn lo so come andra dopo con le coordinate e altre richeieste del progetto.

marchinkus
Siete già a corto di idee?

Benny
scusate, ma la proprietà 3, è spiegata male:
"le caselle non annerite devono formare una sola componente connessa verticalmente e orizzontalmente,
ovvero non devono esserci caselle o gruppi di caselle isolate dal resto dello schema."
però nell'esempio che c'è subito dopo, la soluzione al centro è corretta, allora non devono essere sia orizzontali che verticali, devono essere orizzontali O verticali.
voi che ne pensate?

garfa84
si...nel senso che le caselle bianche non devono essere isolate, quindi una casella è connessa con quella sopra verticalmente oppure con quella di fianco orizzontalmente e quindi in qualche modo collegate..ma per la struttura dati a cosa ti affidi?

marchinkus
La prima proprietà l'avete già implementata ?

PaU
consiglio vivamente di provare a risolvere qualche hitori per gioco.

solo così si capisce bene cosa fare e quando farlo per rislverlo.

io lo sto facendo e sto prendendo degli ottimi spunti...

Benny
io ho implementato struttra dati(hash table), una conversione della struttura per lavorare con piu semplicita, le proprieta 1 e 2, mi metto a fare la 3, ma le euristiche non so se riusciro a farle, perche devo testare tutto quanto, senno non mi serve a nulla tutto questo...
francamente a me non è piaciuto che si rifacesse come febbraio, preferisco 2 appelli distinti, non e giusto secondo me fare cosi...

garfa84
ma l'implementazione l'hai presa da Algo team?

Benny
l'implementazione di cosa?comunque, ho usato la hash table, nella miriade di esempi c'era questa struttura bell'e pronta. Per le 3 proprietà, le ho fatte 2 da solo, la terza veramente devo rivedermi la teoria, in ogni caso, ho provato a giocare sul link che viene dato, ma non riesco a vincere nemmeno una volta...mi chiedo come diavolo farò a verificare tutto sto casino...e ancora non mi sono messo sulle euristiche!

PaU
Originally posted by Benny
io ho implementato struttra dati(hash table), una conversione della struttura per lavorare con piu semplicita, le proprieta 1 e 2, mi metto a fare la 3, ma le euristiche non so se riusciro a farle, perche devo testare tutto quanto, senno non mi serve a nulla tutto questo...
francamente a me non è piaciuto che si rifacesse come febbraio, preferisco 2 appelli distinti, non e giusto secondo me fare cosi...


beh se implementi correttamente le euristiche. le proprietà sono verificare automaticamente...

PaU
Ragazzi attenzione:

il prof non ha previsto un caso (almeno IMHO):

1 1 1 1 1
1 1 0 1 1
1 a 1 0 1
1 1 0 1 1
1 1 1 1 1

anche in questo tipo di configurazione, stando alle regole, la casella con la a non può essere annerita.

Eppure la regola angolo vale solo sugli angoli delle griglie, non su tutto l'hitori...

marcio
Io userei l'albero rosso nero per la griglia,
ma non ho capito una cosa,
da quale casella si parte e con quale principio si sceglie la tecnica di risoluzione con cui cominciare per risolvere l'hitori?
Nell'esempio parte dalla tecnica PI casella 0,1 non avrebbe potuto cominciare con qualcos'altro?

Benny
pau, non saprei..per ora mi sto ammazzando il cervello per implementare la proprietà 3 con una bella visita in ampiezza, tutta da riscrivere (grande inutilità in rete)...però non si rischia di violare una di queste proprietà se si seguono troppo le euristiche?boh, tanto manco riesco a vincere una partita senza le euristiche, figuriamoci con tutte quelle che ci sono...

PaU
beh ma se implementi le euristiche correttamente, le proprietà sono rispettate.

alla fine se la griglia rispetta le proprietà, le euristiche sono fatte giuste, altrimenti qualcosa non va...

PaU
Originally posted by marcio
Io userei l'albero rosso nero per la griglia,
ma non ho capito una cosa,
da quale casella si parte e con quale principio si sceglie la tecnica di risoluzione con cui cominciare per risolvere l'hitori?
Nell'esempio parte dalla tecnica PI casella 0,1 non avrebbe potuto cominciare con qualcos'altro?


la PI inizi ad applicarla per trovare le caselle sicuramente bianche.

avresti potuto cominciare anche con l'angolo in basso, è una scelta libera almeno penso.

marcio
ma non basta secondo voi implementare solo le euristiche? alla fine rispettano le 3 proprietà!

marcio
Ma per implementare tutte le euristiche, le si applica in un ordine particolare o le si fa a caso?

PaU
Originally posted by marcio
Ma per implementare tutte le euristiche, le si applica in un ordine particolare o le si fa a caso?


beh di solito si inizia con la PI (esperienza personale, ho provato a risolverne qualcuno nel tempo libero)

poi le altre le applichi ricorsivamente...SB, NV e A...

marcio
Per la proprietà 3 (della componente connessa) usate una visita di un grafo vero?

Microke
Anche io penso di scegliere un albero Rb..
Benny perchè hai usato proprio l'hash table?

Benny
perchè è la struttura che uso da diversi progetti, e cambiarla vuol dire ripartire da zero...so che per la stragrande maggioranza dei progetti sarebbe più indicato usare un bel grafo e tanti saluti, come del resto anche in questo è la diretta soluzione migliore...però in sintesi sono tutte molto simili, adottano una forma molto diversa ma sempre di puntatori alla fine si tratta...si riesce anche con difficoltà a piegare al proprio volere la struttura che si preferisce..e poi non si ha sufficiente tempo per provare più di una soluzione di struttura dati per lo stesso progetto, quindi meglio non arrovellarsi troppo e darci dentro con la scelta più facile :)

marchinkus
Domandina:
quando finisce il gioco? O meglio, quante volte devo utilizzare le diverse tecniche ?Cosa mi dice "basta"?

AAndrea
quando finisce il gioco? O meglio, quante volte devo utilizzare le diverse tecniche ?Cosa mi dice "basta"?

Il gioco termina al ennesimo battito di clock dove n è ceil log del numero di celle non bianche della tabella hash da voi precedentemente implementata.
Per la proprietà B e garantire una mutua esclusione nel caso di sconfitta per proprietà 2 ( ovvero quando rimani incastrato) io consiglierei un risto orientato

marchinkus
Perchè nei progetti sono richieste strutture che durante il corso di laboratorio non sono nemmeno contemplate? Mi riferisco ad esempio alla gestione di insiemi disgiunti con rappresentazione mediante alberi?E' possibile che per implementare una union-find si debba aspettare il progetto e non una sana e profiqua discussione e implementazione durante le ore di laboratorio?

Garet
Bello oggi guardo se è uscito il progetto visto che era per ieri/oggi la data d'uscita segnata anche sul calendario degli appelli e me lo trovo fuori già da una settimana, andiamo bene -__-'

A sto punto mi sono iscritto pure all'esame di luglio perchè dubito di farcela per il 22 giugno -__-'

Per il progetto a un primo sguardo mi sembra uno dei soliti progetti complicati usciti ultimamente, speriamo in bene...

Benny
garet concordo pienamente con te, e da un po c'e sto sistema della consegna doppia...

marchinkus
Come state procedendo col pogetto?

ivanbag
Scusate, sono io che mi sono perso qualche pezzo del testo, oppure si possono utilizzare le matrici? In altri progetti era espressamente scritto che non potevano essere utilizzate, ma in questo caso o ho letto male, oppure possiamo utilizzarle.
Guardando gli input, il primo numero passato è proprio la grandezza della griglia, quindi è facile costruirci una matrice, in più in questo caso non ci sono piani infiniti o cose del genere, la griglia è per definizione finita... Non so, magari sono io che ho letto male...

Ciau
Ivan

Benny
ivanbag hai perfettamente ragione, infatti io le uso..il problema è che nonostante ho implementato quasi tutto, ho problemi con la memoria..ste maledette cose mi fanno perdere sempre un sacco di tempo..non so neanche come risolverlo sto problema dei passaggi di matrici qua e la..

alien
ciao!
Credo che basta usarne due matrici!
Una in input e l'altra sfrutarla per l'output
In teoria,e anche in pratica funzionano!
Per quanto riguarda il loro uttilizo, il prof mi ha confermato che si possono uttilizare le matrici,quando sono andato a chiedere!

garfa84
ma i valori li inserisco nella matrice ma per implementare le euristiche bisogna basarsi su un albero o è sufficiente la matrice!!!!
perchè io mi sono bloccato nell'inserimento dei valori letti da matrice nell'albero!!

alien
no no niente albero...
le euristiche li implementi con i soliti cicli for per strapolare le coordinate e controllare tutte le celle della matrice, e dei if qua e la per gli appositi controlli

garfa84
e le solite strutture dati utilizzate nei progetti vecchi si vanno a far benedire!!!?
ma così forse ha un senso tutto quanto...

garfa84
ma quindi tu [Alien] sei a buon punto....?

alien
ho trovato delle dificolta sulle due tecniche NI e BI
che sono per la consegna di luglio,visto che io a giugnio devo partire il 20,e non posso consegnarlo!

Garet
Nel progetto non lo dice specificatamente ma immagino, anche dagli esempi visti e dal fatto che venga data solo una dimensione in input, che la griglia dell'hitori sarà sempre un quadrato (indi 4x4, 5x5, 200x200, ecc...), giusto?

davene
up

alien
esato...la dimensione sara n*n

marcodili
ho un dubbio..
lo schema dell'hitori deve essere passato al programma da file (es. txt) oppure deve essere scritto dall'utente su richiesta del programma?

Benny
marcodili, l'input è nella forma:
3
1 2 3
1 2 3
1 2 3
ma io le ho trovate chiare le specifiche, certo sono un po lunghette, ma perche ci sono degli esempi..il difficile per me è vincere anche un solo hitori..

marcodili
si.. ma questo input... deve essere contenuto in un file di testo?

davene
è indifferente...sia che arrivi da standard input (console) o da file di testo è la stessa cosa per il programma.
Non è necessario considerare "da dove arrivi" in quanto la redirezione dell'input / output è una funzionalità che offre il SO stesso.

ivanbag
Originally posted by alien
no no niente albero...
le euristiche li implementi con i soliti cicli for per strapolare le coordinate e controllare tutte le celle della matrice, e dei if qua e la per gli appositi controlli


Ok...
Come procedi per i controlli sulle varie regole?
Per ogni regola ti passi tutta la matrice (ovviamente escludendo le celle già "taggate" dalle altre regole) oppure, al contrario, fai un passaggio unico per ogni cella ed applichi le varie euristiche? Io sono propenso a questa seconda soluzione, questo per evitare di smandrupparmi continuamente la matrice, in teoria (e potrei sbagliare di grosso) dovrebbe essere un più perfomante la seconda soluzione, ma boh!!!!

Ciau
Ivan

marcodili
scusate ma usando le matrici, come fate a tener traccia di quali celle devono per forza essere bianche o quali sono già nere? Avete costruito una seconda matrice che ne tiene conto? Perchè la tecnica suggerita dal prof con -3-, *3*, non credo sia applicabile con le matrici o sbaglio?

garfa84
Io sto usando una matrice di struct, il problema è la ricorsione per effettuare le varie chiamate e il fatto di determinare se la chiamata a non_annerire() viene da PI o da NV
e lo stesso per annerisci()!!!
potete suggerirmi qualcosa...

Lallac10
Ciao a tutti!
Sono pienamente d'accordo con voi che è comodissimo usare le matrici...ma come si implementa la regola 3 per la quale le caselle bianche devono essere una componente connessa????
Certo che è un bel casino questo progetto!!!

marcodili
anche io sono in difficoltà sulla proprietà 3. voi come avete fatto?

Benny
quando sono andato a parlare al prof dopo il progetto di gennaio, mi aveva detto che in generale per ogni progetto vengono chieste:
gestione input(e con faccialibro ci ho perso praticamente settimane)
struttura dati
un algoritmo sui grafi, ovvero una visita in ampiezza o in profondita
la mia proprieta 3 fa qualche cavolata, ma se la cava in qualche modo, quindi non penso possa dare un esempio valido...
ma qualcuno di voi e riuscito a consegnarlo per il 22?come e andata?

PaU
ho dovuto utilizzare un hash come struttura di supporto, altrimenti la uno solo con matrici è abbastanza difficile da implementare.

per la componente connessa penso che si dovranno collegare i nodi in una struttura da albero...vedrò...

marcodili
io per la 1 e la 2 sono riuscito solo con le matrici. è la terza che è problematica. non avete idee?

Lallac10
ciao a tutti domanda....
la terza regola , premetto che ho implementato l'hitori con una tabella, e se per testare la componente connessa creassi un grafo di appoggio solo con le celle bianche, cioè con contenuto diverso da zero?
a me sembra una cosa un pò onerosa ma per ora è l'unica idea che mi è venuta in mente.....avete altre idee?
buona giornata e buon lavoro!!

marcodili
secondo me la cosa migliore è fare tipo una "visita in ampiezza" adattata ad una matrice... e quindi verificare la componente connessa.

Come avete fatto BI e NI?
Nell'esempio il prof usa NI nel (4,2). Però non sarebbe identico il risultato se avesse usato BI in (4,0)? I Altrimenti perchè il professore decide di utilizzare NI in (4,2)?

fain182
non sarebbe meglio una union find per vedere la componente connessa?

Lallac10
Ho un dubbio sulle euristiche..
Non ho capito ma devo usarle per risolvere l'hitori nel senso inserito l'hitori chiamare le euristiche oppure deve esserci una funzione che avuto in ingresso l'hitori lo risolva in autonomia?
proprio non riesco a capire!

garfa84
per la NI e BI come si può fare?...io il resto l'ho fatto con le matrici,ma andrà bene?!!

marcodili
scusate stavo ragionando su NI e BI e mi è venuto un dubbio... da quanto mi sembra di aver capito leggendo il progetto.. BI e NI vengono applicate per ultime se sono presenti due numeri uguali sulle righe o sulle colonne... Però ci sono dei casi in cui forzando la casella e applicando ricorsivamente le regole, non si arriva a una soluzione definitiva perchè rimangono altri numeri uguali sulle righe o sulle colonne...
In questo caso la proprietà 1 non verrebbe rispettata e quindi verrebbe annerita/non annerita una casella che non dovrebbe essere annerita/non annerita.
Quindi se bisogna applicare più volte BI o NI la soluzione dell'hitori non è mai giusta. Mentre se si applicano una sola volta BI o NI la soluzione è sempre giusta.
Qualcuno ha riscontrato questo stesso problema?

garfa84
ma per la tecnica trapezio come avete fatto?

garfa84
non ho capito una cosa...ma per verificare il metodo NI nell' esempio, si fa l'ipotesi che (4,2) sia nero e poi si trova che questo non può avvenire perchè altrimenti le celle nell'angolo rimarebbero chiuse, ma per verificare questa condizione bisogna fare un grafo con una visita per vedere che le celle siano connesse o basta applicare le regole, magari implementandone qualcuna aggiuntiva come ad esempio CLOSE EDGE sul sito http://www.menneske.no/hitori/methods/eng/methodce.html ????????????

ivanbag
Ho un paio o più di domande, magari qualcuno mi sa dare un suggerimento...

1) Con che ordine si possono applicare le euristiche? Le ho implementate tutte, tranne BI e NI che per il momento trascuro, prese singolarmento funzionano bene, in più se faccio piccole "catene" vanno bene, ma non trovo la "catena" unica per farle coesistere tutte... Avete idee in proposito?

2) E' possibile implementare ulteriori euristiche? Da quello che ho letto dalle specifiche quelle indicate sono le minime ed indispensabili, però, come suggerito da garfa84, ci sono regole ulteriori come il closed edge (molto utile per fare in modo che venga rispettata la terza proprietà...)

3) La terza proprietà... Io stavo pensando ad un grafo, ma non vorrei farmi del male... Come la verificate?

Saluti
un Ivan... che finalmente poterci dedicare tempo...

Busla
Sono nella tua stessa situazione...
Hai rappresentato in modo completo e chiaro il problema

Lallac10
Scusate domandona: Come avete implementato la regola trapezio? sono bloccata li per ora, anche perchè non riesco a capire bene la specifica sul progetto...qualcuno può aiutarmi?

garfa84
Io l'ordine delle euristiche le ho applicate nel main a partire da [PI], poi questa richiama una funzione non_annerire che mi chiama [SB] che mi richiama annerisci e così ricorsivamente. Quando non è più applicabile niente richiama trapezio , coppia , angolo che come prima richiamano SB e NV se c'è qualcosa da annerire o no.
In questo modo prendendo l'esempio dato, arrivo fino all' applicazione della regola no (4,3) : A
Rimane da fare NI e BI che devono fare una supposizione su un valore per trovare una contraddizione , pensavo a una pila o una coda per memorizzare la supposizione. E per la terza regola mi viene in mente anche a me un grafo ma è un bel casino.
Anch' io chiedo , ma c'è bisogno di fare un grafo o si può tramite l'implementazione di altre tecniche di evitarlo???

garfa84
io pensavo di andare dal prof a chiedere dei chiarimenti....
qualcuno va in Silab o è già lì a impazzire sul progetto?? magari ci si chiarisce le idee insieme!!!

garfa84
per trapezio io ho controllatto tramite dei cicli for , se ci sono elementi sulla prima colonna uguali a distanza 1 o più e sulla colonna dopo a distanza 2 o + se si richiamo la funzione per annerire il primo elemento in diagonale e poi quell'altro elemento , lo stesso ho fatto per verificare l'uguaglianza sulle righe!!!
Non so se si è capito bene!!!

Lallac10
Quello che non capisco di Trapezio è cosa devo cercare. Cioè cerco di spiegarmi: devo cercare se su una riga i c'è un numero ripetuto a distanza di una cella e nella riga i+1 un altro numero ripetuto a distanza 2?

Busla
Garfa purtroppo non riesco a passare in Silab, non sono di Milano, e non riesco con il lavoro a scendere apposta...

garfa84
Quello che non capisco di Trapezio è cosa devo cercare. Cioè cerco di spiegarmi: devo cercare se su una riga i c'è un numero ripetuto a distanza di una cella e nella riga i+1 un altro numero ripetuto a distanza 2?

Giusto ma lo devi fare non solo a distanza di una cella, ma anche a distanza 2 , 3 ...n-2 e nella riga i+1 a distanza 2 ,3 ... n-1

Lallac10
ma così è da impazzire!!!!!!

garfa84
Sono passato dal prof e quello che ne ho ricavato è che:
le euristiche da implementare sono quelle scritte, se uno vuole aggiungerne altre tipo quelle del sito suggerito, può tranquillamente.

Mi ha spiegato come dovrei fare con [NI]
cioè supporre sui valori che rimangono, bisogna memorizzare la supposizione da qualche parte(coda,pila,variabili addirittura).
cioè suppongo 1 (4,2) annerito allora dico 1 (4,0) può essere nero o bianco.
Nero non può essere perchè se no rimane chiuso 2. e cancello nero. vado avanti con la supposizione di 1(4,0) bianco e poi sarà 1(2,0) bianco o nero, non può essere ne bianco ne nero allora 1(4,2) non può essere nero e sarà bianco.

Quello che mi chiedo come faccio a memorizzare la supposizione?
e per la verifica che il 2 non rimanga chiuso bisogna applicare la regola 3 non close_edge, perchè nel caso specifico vabe ma in altri casi potrebbe non andare bene!!!quindi come faccio a verificarlo???

Lallac10
quindi stai dicendo che annerisci e non_annerisci non sono obbligatorie come implementazione....
ma allora come faccio a risolvere l'hitori.....qualcosa mi dice che questo progetto non lo consegnerò.....ufffff

garfa84
io annerisci e non_annerire le ho implementate...adesso provo a guardare come implementare il backtracking per fare la supposizione..mi ha parlato di esempi fatti a lezione (mosse del cavallo, o regina)....io devo consegnarlo perchè non ho voglia di sbattere la testa su un altro progetto!! quindi uniamo le forze!!

Lallac10
si se è per quello nemmeno io ma qui è un bel pò incasinato

Busla
Si nelle slide mi ricordo l'esempio della scacchiera con il cavallo.
Nella quinta lezione se non ricordo male
Ora mi riguardo un pò tutto.
Grazie Garfa!

ivanbag
Immaginavo che BI e NI fossero da applicare alle celle non ancora controllate, mi mancano solo loro e poi ho implementato tutto. Devo solo farlo funzionare... ahahaha

Io T l'ho implementata più o meno così:
se mat[0][0].num == mat[2][0].num && mat[0][1].num == mat[3][1].num ... ovviamente questo è solo uno dei tanti if (all'interno dei for) del trapezio, per esempio devo controllare che che gli indici durante i for di controllo non escano dalla matrice, oppure "il senso" del trapezio, perché, per come l'ho interpretato io, può essere "girato" in modi diversi... E adesso che ci penso non ho provato a farlo con i due vicini in basso ed i diagonali in alto O_O , corro ssssubito ad aggiungere quella parte!

annerire e non_annerire io le ho implementate per comodità, ma effettivamente possono non essere obbligatorie. Le ho trovate comode perché le implementi una volta sola e le riusi spesso, in più al loro interno è facile inserire le chiamate alle euristiche che applichi solo quando annerisci o non annerisci una cella... In questo modo con una funzione le chiami tutte ;)

Originally posted by garfa84

Quello che mi chiedo come faccio a memorizzare la supposizione?
e per la verifica che il 2 non rimanga chiuso bisogna applicare la regola 3 non close_edge, perchè nel caso specifico vabe ma in altri casi potrebbe non andare bene!!!quindi come faccio a verificarlo???


Me lo chiedo anch'io... Oggi ragiono per bene alla terza regola, vediamo se ne cavo fuori qualcosa...

Ivan

Lallac10
in pratica annerisci e non_annerire richiamano rispettivamente:
NV A e non_annerire, mentre non annerire richiama SB e annerisci.
Il mio dubbio resta su come gli passo le coordinate su cui eseguire annerisci e non annerire quando non è la prima chiamata? Oppure devo inserire nelle euristiche le chiamate alle due funzioni ricorsive?
a me mancano queste due e NI BI poi ovviamente farlo funzionare

ivanbag
Cosa intendi per "passare le coordinate"?
Io annerisci l'ho strutturata così:
code:
void annerire( matrice m[M][M], int x, int y ) { if( ... ) { ... nv( m, x, y ); a( m ); } else ... }

Dove x e y sono riga e colonna della cella da annerire...
nv prende gli stessi x e y e fa i suoi controlli all'interno, mentre a non avevo voglia di sbattermi a farla per singolo angolo, quindi ogni volta che annerisco qualcosa me li controlla tutti e 4, anche perché ho notato che se le euristiche funzionano è facile che per reazione a catena si arrivi agli angoli, quindi è meglio controllarli spesso...

Spero di aver capito la domanda ed esserti stato utile :)
Ciau
Ivan

Lallac10
si ok ora mi sorge un'altra domanda....la chiamata ricorsiva a annerisci o non annerisci avrà dei parametri che saranno la matrice e le due coordinate o x e y come le hai chiamate tu su cui eseguire le euristiche.... per quello che mi chiedevo se le chiamate ricorsive devono essere all'interno delle euristiche....è questo il mio problema! o almeno uno dei tanti:)

ivanbag
Ok...

Allora, ti porto il mio esempio per CS. Al suo interno, una volta eseguiti i controlli, passo ad annerire la matrice e le coordinate della cella. Da annerire chiamo:

- NV che a sua volta chiama non_annerire passando matrice e cella e con gli stessi parametri chiama anche SB. SB a sua volta chiama annerire. Qui ho avuto il primo problema, perché come noterai rischia di continuare il giro all'inifinito, per fare questo ho fatto in modo che nv controlli con un if le celle vicine, se sono già state "toccate" non fa partire SB, al contrario, se non sono state "toccate" SB parte. Ovvio che al primo giro parte e al secondo no.
- A che, come dicevo prima, controlla tutti gli angoli, quindi gli passo solo la matrice. Al suo interno richiama solo non_annerire. Non ho ancora deciso se far partire SB anche all'interno di A, questo mi creerebbe qualche casino con l'impostazione che ho dato.

E' importante mettere uno "stop" forzato alle continua chiamate o ti perdi in un bel loop... Ieri mattina ho cristato parecchio perché non capivo come fare... Spero di essere stato chiaro, è abbastanza un casino a parole, parla meglio il codice, ma non posso metterlo :P

Ciau
Ivan

EDIT: per BI e NV mi è venuto in mente che posso sfruttare l'impostazione che ho dato. All'interno della matrice di strutture che ho creato ho un int che contiene il numero e ho un int che fa da "tag" per le celle già controllate. Quelle ancora non controllate hanno un determinato "tag". Una volta terminate le euristiche è facile scorrere la matrice alla ricerca delle celle non visitate. Da qui si può scegliere se lavorarci direttamente oppure crearsi una struttura esterna ed applicare BI e NV ed eventuali altri controlli...

Lallac10
ok quindi tu per ogni euristica richiami rispettivamente o annerire o non annerire giusto? non voglio vedere il tuo codice ma cercare di capirne un pò di più:)

ivanbag
Originally posted by Lallac10
ok quindi tu per ogni euristica richiami rispettivamente o annerire o non annerire giusto? non voglio vedere il tuo codice ma cercare di capirne un pò di più:)


Esatto, per ogni euristica richiamo annerire e/o non_annerire. Come dicevo annerire a sua volta richiama euristiche... Un bel macello ^^

Ivan

garfa84
Originally posted by ivanbag

EDIT: per BI e NV mi è venuto in mente che posso sfruttare l'impostazione che ho dato. All'interno della matrice di strutture che ho creato ho un int che contiene il numero e ho un int che fa da "tag" per le celle già controllate. Quelle ancora non controllate hanno un determinato "tag". Una volta terminate le euristiche è facile scorrere la matrice alla ricerca delle celle non visitate. Da qui si può scegliere se lavorarci direttamente oppure crearsi una struttura esterna ed applicare BI e NV ed eventuali altri controlli...


Ok , anch'io avevo pensato di usare l'int della struct per vedere i numeri che mi rimangono da decidere, i e j che sono gli indici della matrice[i][j] li ho per identificare il numero in questione...in base a questo devo fare la supposizione che sia nero, ma dove la metto sta supposizione????....:?

e non ho ancora capito come fare x la componente connessa, cioè il prof mi ha detto che andrebbe verificata ogni volta che devo decidere se annerire o no una cella.....

Lallac10
Originally posted by ivanbag
Esatto, per ogni euristica richiamo annerire e/o non_annerire. Come dicevo annerire a sua volta richiama euristiche... Un bel macello ^^

Ivan


ora ho un'altra domanda...sull'esempio fornito viene richiamato più volte e di seguito PI che nn rientra nelle euristiche inserite nelle funzioni ricorsive annerire o no

garfa84
si perchè non annerire lo eseguo fin tanto che può essere applicato e siccome nell'esempio quelle chiamate a PI richiamo non_annerire che a sua volta richiama solo una bianco, ma questo non trova niente a annerire, riesegue PI fin quando trova valori che soddisfano l'euristica!!

ivanbag
Originally posted by garfa84
Ok , anch'io avevo pensato di usare l'int della struct per vedere i numeri che mi rimangono da decidere, i e j che sono gli indici della matrice[ i ][ j ] li ho per identificare il numero in questione...in base a questo devo fare la supposizione che sia nero, ma dove la metto sta supposizione????....:?


Potresti crearti all'interno della struct (se usi una struct ovvio) una variabile apposita che, se diversa da zero, stai supponendo la cella nera... Ovviamente adattandola al tuo caso.

Originally posted by garfa84
e non ho ancora capito come fare x la componente connessa, cioè il prof mi ha detto che andrebbe verificata ogni volta che devo decidere se annerire o no una cella.....


Ecco, questo è il punto dolente... Le verifiche delle proprietà 1 e 2 sono facili, ma questa... Io sto provando ora a metterle giu tramite grafo... Non ho trovato ancora una soluzione migliore... Se una qualche cella, coppia di celle o insieme di celle non è connessa al resto del grafo la regole 3 non è verificata... Solo è da implementare...

Ciau
Ivan

Lallac10
io per la regola 3 ho trattato la matrice come se fosse un grafo testando le prime 2 celle se sono nere e per la prima che non lo è guardo gli adiacenti a croce cioè dx sx su giù e metto le coordinate in una coda poi fino a quando la coda non è vuota faccio lo stesso per tutti gli adiacenti. per capire se ho toccato tutti i nodi ho 2 contatori che mi contano le celle nere e le celle bianche che ho visitato se la loro somma è diversa dal numero di celle totali della griglia allora la griglia non è connessa


EDIT: ho provato a eseguire manualmente la catena di euristiche e arrivati al punto no (2,3)PI li dovrebbe poi applicare SB non di nuovo PI.....se non è così allora non ci ho ancora capito molto

garfa84
si lo esegue SB ma non ci sono valori per cui stampa il messaggio no (x,x) : SB...l'esecuzione avviene sempre dopo non_annerire ma non sempre trova valori!!!

io per la regola 3 ho trattato la matrice come se fosse un grafo testando le prime 2 celle se sono nere e per la prima che non lo è guardo gli adiacenti a croce cioè dx sx su giù e metto le coordinate in una coda poi fino a quando la coda non è vuota faccio lo stesso per tutti gli adiacenti. per capire se ho toccato tutti i nodi ho 2 contatori che mi contano le celle nere e le celle bianche che ho visitato se la loro somma è diversa dal numero di celle totali della griglia allora la griglia non è connessa


ma la regola la controlli sempre?
ma quindi cosa fa nel primo passo vede 0,1 non nera e mette nella coda (0,2)(0,0)(1,0)..e poi controlla i valori nella coda

Lallac10
il primo passo è il controllo di 00 se è nero incremento il contatore nero, e setto 1 il visitato di 00, poi passo a 01 e quello se è bianco controllo a croce e metto quelli non neri nella coda
e così via incrementando per ogni bianco il contatore bianco

non capisco la tua risposta però.....ci sono due numeri uguali su quella riga....eppure la considera dopo molto....boh

garfa84
si ma il PI non_annerisce il 4 e non ci sono 4 sulla stessa riga o colonna..no?!

garfa84
scusa un'altra domanda...ma il controllo sulla regola 3 al momtento di eseguire nero_impossibile , cioè alterzultimo passo o anche nei passaggi precedenti???

Lallac10
già......perchè tiene in considerazione la casella che non viene annerita.....ok

Lallac10
:) non ho ancora implementato e pensato a NI e BI

garfa84
ma per bianca intendi che non si sa ancora o che è già stato determinato che sarà bianca???

Lallac10
no beh prima di tutto la regola 3 viene applicata su una griglia risolta quindi sai già che se è nera o bianca, e nel caso di BI o NI tu presupponi che sia nero consideri nera la cella e vice versa la consideri bianca

garfa84
Lallac10 ma la regola 3 l'hai implementata con un grafo vero e proprio, cioè creando il grafo e facendo una visita o solo con controlli per i valori della matrice?

Lallac10
niente grafo, solo prendendo in considerazione le celle con coordinate (i-1, j)(i+1,j)(i,j-1)(i,j+1) e basta solo quello ma ovviamente controllando che gli indici non escano dai limiti della matrice

ivanbag
Tralasciando la regola 3 che mi sta dando ancora qualche grattacapo...
Ora mi sorge un problema, sto mettendo giu la gestione dell'input... Voi come avete fatto? Per il momento utilizzavo una matrice dichiarata all'interno, ma ora vorrei iniziare a passargliela di volta in volta... Avete qualche idea? Io sinceramente sulla gestione degli input non sono molto sveglio :D
Ho provato con gets, ma se compilo con --ansi mi dice che è è pericolosa:
/tmp/cceIIiNg.o: In function `main':
input.c: (.text+0x39): warning: the `gets' function is dangerous and should not be used.


Ciau
Ivan

ivanbag
Bene, ho la verifica di tutte e tre le regole funzionante, almeno, per tutti gli input provati fin'ora sembrano funzionare.
Il tutto senza BI e NI che mi danno problemi seri... Se riesco a sistemare anche queste due mi manca *solo* il rendere le matrici dinamiche e poi sono a posto... Dico solo perché prevedo parecchi fault tra malloc e puntatori...

Che ragionamento avete fatto per BI e NI? A me è un po' poco chiaro quel che devono fare... Almeno, come le ho interpretate io non funzionano O.o

Ciau
Ivan

garfa84
anch'io ci sono con le tre regole...x la terza con 2 funzioni che finalmente funziona!!!
Devo fare BI e NI!!!
Ho 2 domande:
1)la regola 3 bisogna verificarla sempre o solo quando si applica NI e BI e nel caso dell' input con zeri, perchè nell'esecuzione delle euristiche non mi pare vada mai a contraddire la regola 3

2)l' input con zeri come fate a diferenziarlo da quello senza, cioè non fargli stampare i passaggi che svolge, perchè io stampo il messaggio del passo eseguito appena lo esegue

Powered by: vbHome (lite) v4.1 and vBulletin v2.3.1 - Copyright ©2000 - 2002, Jelsoft Enterprises Limited
Mantained by dsy crew (email) | Collabora con noi | Segnalaci un bug | Archive | Regolamento |Licenze | Thanks | Syndacate