.dsy:it. (http://www.dsy.it/forum/)
- Algoritmi e strutture dati (http://www.dsy.it/forum/forumdisplay.php?forumid=207)
-- Progetto "Componenti Elettroniche" (http://www.dsy.it/forum/showthread.php?threadid=40479)

Progetto "Componenti Elettroniche"

E' uscito il nuovo progetto di Algoritmi.

Apro un thread per chi come me pensa (deve) farlo x l'8 giugno!!

ci son dentro ankio in quel "deve", se voglio laurearmi a dicembre. Per ora gli ho dato una prima lettura veloce e pensavo peggio.

Boh, vediamo un po'... teniamo questo thread come riferimento

Anke io mi "devo" laureare a dicembre....
Onestamente anche io pensavo peggio, invece tutto sommato per giugno (forse è x questo ke danno meno gg del solito) non è poi cosi catastrofico come pensavo...
Spero d nn dovermi ricredere!!!

mi aggiungo al coro dei "devo" e vi lascio già un dubbio...
ho guardato gli esempi di codice da provare e i relativi messaggi...
nel primo L (lineare) ovvero l'istruzione
l 2 7 17 24 26
il risultato del professore è:
69:
[
3 2 10 5 5, 2 (c5)
12 3 6 4 3, 7 (c1)
100 2 5 3 8, 17 (c3)
74 7 4 2 4, 24 (c6)
]

Nelle direttive del testo però dice che l'istruzione lineare può dare diverse soluzioni e infatti in questo caso le soluzioni possibili equivalenti sono:

c5 c1 c3 c6 (quella indicata dal professore)
c5 c2 c3 c6
c5 c3 c1 c6
c5 c3 c2 c6

Mi verrebbe da pensare che sia indifferente postare una o l'altra soluzione, ma più volte nella creazione dei dispositivi si dice che conta l'ordine dei componenti...quindi la soluzione giusta è solo la prima??

allora nel testo dice che un dispositivo è lineare se le posizioni dei componenti sono in ordine crescente, e se la posizione di una componente+la larghezza da esso occupata è minore o uguale della posizione del componente dopo.
quindi credo che sia x questo che ha scelto solo la prima xke sono tutti dispositivi ma la funzione lineare deve restituire solo il dispositivo lineare che ha la massima occupazione

Che struttura dati ipotizzate?

Rileggendo mi sembra che l'idea migliore sarebbe di avere una lista normale per i componenti e un albero rosso-nero.
Secondo voi?

cmq anche il secondo dispositivo (c5 c2 c3 c6) ha la stessa estensione del primo e soddisfa la proprietà di linearità. L'unica differenza sta nel secondo componente che è un 6x2 invece del c1 del (c5 c1 c3 c6) che è un 4x3 ma l'estensione rimane sempre la stessa.
Rileggendo ho notato che c'è scritto che il dispositivo lineare da x a xk+1 non per forza deve essere unico. Quindi entrambe le soluzione proposte dovrebbero andare bene come risultato (c5 c2 c3 c6) e (c5 c1 c3 c6). Per le altre due invece, che hanno gli stessi componenti del primo disp (c5 c1 c3 c6), ci deve essere qualcosa sull'ordine dei componenti che mi sfugge...

Infatti quando viene spiegata la funzione "lineare" si dice che ci possono essere più soluzioni, però mi chiedevo se era indifferente darne una o l'altra oppure va indicata in ordine di costruzione del componente... Il professore dice che l'ordine di fissaggio è rilevante...
Le ultime due soluzioni penso sia valide altrettanto perchè vengono rispettati i vincoli ed essendo uguali i pezzi anche l'estensione resta invariata...

Per quanto riguarda la struttura anche a me è venuta subito in mente una lista...infondo non ci sono eliminazioni, bisogna fare qualche inserimento e molte ricerche... forse utilizzando un grafo si migliorerebbe il tempo di ricerca però sarebbe difficile indicizzarlo perchè bisognerebbe capire bene qual'è il parametro da indicizzare...
Se conta l'ordine di inserimento la lista facilita tutto, altrimenti con il grafo si potrebbe indicizzare per codice (velocizza gli inserimenti) o per lunghezza/estensione (velocizza la funzione lineare)...

Ho riletto più volte, ma a parte trovare la frase " L'ordine di fissaggio delle componenti è rilevante" più volte non riesco a capire il perchè di tutta questa rilevanza boh...
Per ora mi riguardo un po di C con cui non ho molta dimestichezza prima di incominciare a scrivere codice a caso pieno di errori

Io ho pensato a un grafo/albero per quanto riguarda le componenti, facendo inserimento in ordine di codice identificativo
Il fatto è ke ci sono 3 funzioni di ordinamento che però hanno criteri diversi:
ordina devi stampare tutti i componenti secondo il costo; mentre stampa devi stampare i componenti in ordine di codice, e stampa f idem solo ke devi controllare ke facciano parte di una sola famiglia.

però ho due dubbi:
1. nelle componenti voi memorizzate lunghezza e altezza o anche l'area visto che nella funzione lineare l'estensione del dispositivo è la somma delle aree?
2. i dispositivi li memorizzate in una struttura oppure non ce ne bisogno visto che lavoriamo in tutte e 5 le funzioni solo con le componenti?

ciao mi aggiungo per appello di giugno...
la domanda è come cercare ed ordinare una lista secondo i dati satellite ?
cioè come stampare i componenti in ordine di codice, se ho una lista con chiave costo?
avevo pensato ad inserire ogni componente nelle 3 liste ordiante secondo 3 diversi criteri... costo , codice, famiglia
per la parte dei dispositivi avevo persato ad un ulteriore struttura ad albero...
che ne pensate ?

oltretutto per le componenti non ho visto la parte di cancellazione o mi sbaglio

Originally posted by Guepe
Per ora mi riguardo un po di C con cui non ho molta dimestichezza prima di incominciare a scrivere codice a caso pieno di errori

hai ragione...questo vorrebbe dire però che se non usiamo una lista ma un grafo, le componenti debbano essere indicizzate in base al codice indentificativo... però nell'ordinamento per costo e nella funzione lineare, ci andiamo a complicare la vita...il tutto senza contare che se bisogna veramente tenere conto dell'ordine di fissaggio è ancora più complicato

Ciao a tutti,

io sono rimasto un passo indietro... non riesco a capire nell'esempio con i due dispositivi:

D1 = ((c6,20),(c5,19),c1,4),(c4,2),c2,7)) e D2=((c2,1),(c3,8),(c1,11))

come ha fatto a calcolare l'estensione del primo dispositivo... il secondo l'ho capito... è la somma delle aree ma il primo no....

grazie

Originally posted by pirlo21
hai ragione...questo vorrebbe dire però che se non usiamo una lista ma un grafo, le componenti debbano essere indicizzate in base al codice indentificativo... però nell'ordinamento per costo e nella funzione lineare, ci andiamo a complicare la vita...il tutto senza contare che se bisogna veramente tenere conto dell'ordine di fissaggio è ancora più complicato

Originally posted by elrod
Ciao a tutti,

io sono rimasto un passo indietro... non riesco a capire nell'esempio con i due dispositivi:

D1 = ((c6,20),(c5,19),c1,4),(c4,2),c2,7)) e D2=((c2,1),(c3,8),(c1,11))

come ha fatto a calcolare l'estensione del primo dispositivo... il secondo l'ho capito... è la somma delle aree ma il primo no....

grazie

Originally posted by carla86
l'estensione del primo dispositivo la devi calcolare calcolando le aree dei componenti, ma facendo attenzione ha sommare una volta sola le aree sovrapposte.
Io ti dico come l'ho calcolata io:
-parto da il componente che hai in posizione 19 che è il componente c5 che ha area 5x5; il componente in posizione 20, ossia c c6 è completamente sovrapposto dal componente c5 di cui hai gia calcolato l'area quindi c6 nn lo consideri senno riconsidereresti due volte la stessa area.
- hai in posizione 2 il componente di area 10x1, ma in realtà ha solo 2 unità della sua area non sovrapposte da nessun altro componente
-poi ce il componente in posizione 4 ossia il componente c1 che ha area 4x3
-e poi ce il componente in posizione 7, ossia il componente c2 che però è in parte sovrapposto dal componente c1 di cui hai gia calcolato l'area quindi da questo devi togliere la parte sovrapposta.
calcolato cosi ti viene esattamente 49 come da lui calcolato.

Originally posted by carla86
appunto xke ci sono più criteri di ricerca che secondo me dobbiamo usare la struttura dati su cui la ricerca costa meno.
poi conta che su due funzioni componente (in cui cmq devi cercare se gia esiste) e in stampa, devi ordinare le componenti in ordine di codice, in una di costo e in stampa in base alla famiglia è sempre in ordine di codice..
quindi io credo ke opterò x indicizzare su codice identificativo.

Ma scusate, non riesco a capire come vengono definiti i ganci, come faccio a sapere che un componente parte dalla posizione 20 piuttosto che da un'altra? Nell'esempio del prof il gancio non viene mai dato come input

Originally posted by kalbiz
mi sembra corretto, utilizziamo una struttura dati ad albero.
probabilmente mi sfugge però qualcosa a prescindere dalla struttura utilizzata, quando faccio una ricerca, la faccio per chiave ...
se memorizzo nel mio albero binario di ricerca come chiave il codice, come sembrerebbe ovvio, come faccio poi a ricercare per famiglia ? o ordinare in base al costo ?

Originally posted by BeppeGoal
Ma scusate, non riesco a capire come vengono definiti i ganci, come faccio a sapere che un componente parte dalla posizione 20 piuttosto che da un'altra? Nell'esempio del prof il gancio non viene mai dato come input

Io gli scrivo subito, o al massimo domani mattina.
Se mi risponde posto quel che mi dice, se qualcun altro ha info su questo punto, faccia lo stesso.

Il Professore mi ha risposto di riguardare le specifiche relative ai comandi "lineare", "estensione" e "prospetto".
Estensione e prospetto sono nella parte di progetto del secondo appello.

Ci sto ragionando ma per ora mi sfugge.

anche per me è abbastanza nebulosa ...
come faccio a definire un Dispositivo ??
D =(<c1,x1><c2,x2>...<cn,xn> )

le coordinate non vengono mai inserite ??

Qualcuno ha capito qualcosa in merito alla definizione / posizionamento dei ganci?

ciao a tutti...a quanto ho capito io la funzione lineare fissa la posizione dei componenti al momento della chiamata alla funzione stessa:::
l(2 7 17 24 26) significa che:
si ha a dispozizione 26-2=24 come lunghezza max del dispositivo;
il primo componente deve avere lunghezza <= di 7-2=5 unità;
il secondo <= 17-7=10 unità;
il terzo <=24-17=7 unità;
il quarto <=26-24 unità..
per questo motivo i dispositivi possono essere piu di uno e di questi si vuole stampare solo quello avente area totale maggiore....
Il problema appunto è ke se come primo componente ad esempio, nella struttura dati ce ne sono 4 che nn superano la lughezza, come secondo ce ne sono 6,ecc.....bisogna provare un numero abbastanza grosso di combinazioni per ottenere i dispositivi
il problema quindi è che quello di implementare un algoritmo che provi tutte le possibili combinazioni sui componenti

oops.. post sbagliato...

__________________
Software Failure: Guru Meditation

mi blocca per ora un problema ancora più semplice ...
come gestire lo stream di dati in input ??

ho provato con il codice qua sotto ma ... va a seconda dei casi ... cioè ogni tanto funziona ogni tanto noooooooooooooo


array = (int *)malloc(sizeof(int) * 6 ); /* minimo componente */

prevSize = 6;

num = 0;

do { /* Continua finché vengono inseriti numeri */
scanf("%d",&x);

if(num >= prevSize) { /* ri-allochiamo */

prevSize += 2;

array = (int *)realloc(t, sizeof(int) * prevSize );

}


t[num++] = x;

}while((ch=getchar())!='\n');


avete idea del perchè ?? vedete errori ??

Per la disposizione lineare dopo un po di prove penso di aver capito il perchè scelga proprio quella anche se ne esistono altre con dimensione massima uguale ma ordine diverso di componenti.
Per l(2 7 17 24 26) sceglie il dispositivo formato dalle componenti che hanno maggior estensione e che soddisfano il criterio di linearità.
Ci sono 8 (se non mi sbaglio) possibili dispositivi lineari formati da:
c1 (L=4 E=12) posizioni possibili: 1°,2°,3°
c2 (L=6 E=12) posizioni possibili: 2°,3°
c3 (L=3 E=24) posizioni possibili: 1°,2°,3°
c5 (L=5 E=25) posizioni possibili: 1°,2°,3°
c6 (L=2 E=8) posizioni possibili: 4°
Dovendo avere estensione massima il dispositivo dovrà contenere per forza c5,c3 e uno tra c1 e c2 che hanno estensione uguale, ed ovviamente c6 che è l'unico a soddisfare il criterio linearità per l'ultima posizione.
Da una prima analisi, visto che nell'esempio diceva che le soluzioni possibili erano soltanto (c5,c1,c3,c6) e (c5,c2,c3,c6) ho pensato che scegliesse l'ordine dei componenti in base anche alla lunghezza di essi, infatti alla prima posizione sceglie c5, alla seconda sia c1 che c2 e alla terza c3 ma poi come soluzione finale nell'output sceglie (c5,c1,c3,c6) e quindi sto criterio va a farsi benedire....
bah pensavo di aver trovato una soluzione ma invece mi ritrovo punto a capo, quindi mi continuo a domandare perché proprio (c5,c1,c3,c6) è quella giusta quando

(c5,c2,c3,c6)
(c1,c3,c5,c6)
(c1,c5,c3,c6)
(c3,c2,c5,c6)
(c3,c5,c2,c6)
(c5,c3,c2,c6)
(c3,c1,c5,c6)

hanno estensione uguale e rispettano il criterio di linearità????

ragazzi volevo un aiuto: un consiglio su come fare ad inserire nel main i comandi "o" ed "l" (seconda e quarta riga della tabella).
grazie

Una domanda ke vi può sembrare idiota, ma in qst momento sono alla frutta...

Nella funzione ordina e nella funzione lineare il numero dei parametri non è specificato, potrebbero essere 2, come 3, come 4; giusto?
allora come fate nel leggere l'input?
nel case 'o' e nel case 'l' cosa fate, prima un ciclo ke vi conti quanti parametri avete e poi un ciclo ke ve li memorizza in un array? oppure mi sfugge qualche funzione o modo più immediato x sapere il numero dei parametri?

grazie mille

Originally posted by Guepe
Per la disposizione lineare dopo un po di prove penso di aver capito il perchè scelga proprio quella anche se ne esistono altre con dimensione massima uguale ma ordine diverso di componenti.
Per l(2 7 17 24 26) sceglie il dispositivo formato dalle componenti che hanno maggior estensione e che soddisfano il criterio di linearità.
Ci sono 8 (se non mi sbaglio) possibili dispositivi lineari formati da:
c1 (L=4 E=12) posizioni possibili: 1°,2°,3°
c2 (L=6 E=12) posizioni possibili: 2°,3°
c3 (L=3 E=24) posizioni possibili: 1°,2°,3°
c5 (L=5 E=25) posizioni possibili: 1°,2°,3°
c6 (L=2 E=8) posizioni possibili: 4°
Dovendo avere estensione massima il dispositivo dovrà contenere per forza c5,c3 e uno tra c1 e c2 che hanno estensione uguale, ed ovviamente c6 che è l'unico a soddisfare il criterio linearità per l'ultima posizione.
Da una prima analisi, visto che nell'esempio diceva che le soluzioni possibili erano soltanto (c5,c1,c3,c6) e (c5,c2,c3,c6) ho pensato che scegliesse l'ordine dei componenti in base anche alla lunghezza di essi, infatti alla prima posizione sceglie c5, alla seconda sia c1 che c2 e alla terza c3 ma poi come soluzione finale nell'output sceglie (c5,c1,c3,c6) e quindi sto criterio va a farsi benedire....
bah pensavo di aver trovato una soluzione ma invece mi ritrovo punto a capo, quindi mi continuo a domandare perché proprio (c5,c1,c3,c6) è quella giusta quando

(c5,c2,c3,c6)
(c1,c3,c5,c6)
(c1,c5,c3,c6)
(c3,c2,c5,c6)
(c3,c5,c2,c6)
(c5,c3,c2,c6)
(c3,c1,c5,c6)

hanno estensione uguale e rispettano il criterio di linearità????

Riguardo alla funzione lineare avevo posto lo stesso dubbio qualche giorno fa...bisogna capire il criterio di scelta tra le varie soluzioni...

Per la struttura dati anch'io ho usato un albero, però ora che sono alle prese con la funzione lineare non ne sono più molto convinto...
Infondo sto albero va bene solo per l'inserimento perchè per la funzione ordina e la funzione lineare è un casino...panico

Originally posted by carla86
anke qui magari è una risposta stupida xo' ho fatto questo ragionamento:
siamo tutti daccordo ke x avere l'estensione massima deve per forza avere c5 e c3. poi l'unica che ci sta in posizione 4 è c6.
ora poteva scegliere tra c1 e c2 ma siccome sono tutte e due con estensione uguale ha scelto quella che è stata inserita x prima (in ordine lessicografico) e quindi c1?!
come ragionamento potrebbe essere o è una cavolata?

Alla fine voi come struttura x cosa avete optato? Io ho optato per un'albero red-black.

scusa ma x la funzione ordina: conta ke lui ti da un tot d codici identificativi e se quei codici identificativi li trovi allora devi stamparglieli ordinati per costo..
forse x questo caso è meglio crearsi una lista d supporto dove ordinare i nodi ke hanno corrispondente codice identificativo e ke hai estratto dall'albero.

mi sai dire come fare a leggere un numero variabile di interi; ossia mi spiego meglio, nella funzione ordina (e neanche in quella lineare) non ti dice a priori quanti elementi ti darà...
come fai?
ad esempio nel comando
o 5 27 89 65
ti da 4 codici identificativi (ma potrebbe dartene 5 oppure 2 oppure 8) come fai?
se leggo un numero alla volta, faccio partire la funzione d ricerca nell'albero, se lo trova lo voglio mettere in un array di supporto cosi ke una volta trovati tutti li ordino x costo.
ma nn sapendo quanti sono posso ogni volta riallocare l'array di una posizione in più con la calloc?
voi come fate?

Originally posted by Guepe
allora dovrebbe essere (c1,c3,c5,c6) la sequenza corretta se si guardasse l'ordine di inserimento, o anzi (c5,c3,c1,c6) seguendo prima l'ordine per estensione e in caso di ugualianza in base all'inserimento....

no hai ragione rileggendo e ripensandoci non si riesce proprio a capire questo criterio...
mi sa che domani farò un salto in comelico e se il prof è li chiedo se posso salire un attimo a farmi spiegare sta cosa, perchè proprio non si capisce.. mah

Originally posted by carla86
no no io continuavo il tuo ragionamento.
secondo me è giusto come hai ragionato tu e l'ultima scelta che ha fatto il prof ossia se scegliere tra c1 e c2 ha scelto il primo in ordine lessicografico perchè l'estensione era uguale.

dobbiamo mettercela tutta x finirlo entro l'8 giugno!!!
cmq io x le strutture dati ho scelto un albero red-black per inserire tutte le componenti.
per quanto riguarda ordina e lineare ho qualche problema d input e poi effettivamente invece che copiarle in array potrei metterli in una lista per ordinarli e stamparli..
in che ordine d tempo si ordina su una lista d pochi elementi?
xke x la ricerca sono sicura ke la cosa migliore sia l'albero red-black (letto anke sulle slide di aguzzoli) ma x ordinare pochi elementi ke tiriamo fuori dall'albero possono essere valide?
effettivamente anke x lavorare sui dispositivi mi sa ke abbiamo bisogno di memorizzare i nodi che tiriamo fuori, anche se non so con che criterio tirarli fuori...

Originally posted by lux87
ragazzi volevo un aiuto: un consiglio su come fare ad inserire nel main i comandi "o" ed "l" (seconda e quarta riga della tabella).
grazie

io sto usando un albero RB per le componenti,
per la funzione ordina ho pensato di ricercare nell'albero se esiste un componente con il codice che mi viene passato,
se viene individuato, viene inserito in una lista di appoggio tenuta ordinata per costo ...

per l'inserimento di più codici utile per
ordina e lineare ,
ho usato la funzione postata sopra, legge un tot di int e rialloca lo spazio se ne serve ....

edit

sto guardandi gli alberi RB e non ho esperienza di questi quindi chiedo consigli.

avendo implementato l'albero ed avendolo popolato, non mi è chiaro ora cosa passare come parametri alle seguenti funzioni per la visita dei nodi in ordine

grazie

void inord(rbnode *p, rbnode *nil, void (*op)(rbnode *))
{
if(p != nil) {
inord(p->left,nil,op);
(*op)(p);
inord(p->right,nil,op);
}
}

/ **************************************************
**************************/
/*procedura che serve alla visita ordinata del grafo rb, chiama specificando il nodo di partenza*/
void inorder(rbtree *p, void (*op)(rbnode *))
{
inord(p->root, p->nil, op);
}

Originally posted by misterx
sto guardandi gli alberi RB e non ho esperienza di questi quindi chiedo consigli.

avendo implementato l'albero ed avendolo popolato, non mi è chiaro ora cosa passare come parametri alle seguenti funzioni per la visita dei nodi in ordine

grazie

void inord(rbnode *p, rbnode *nil, void (*op)(rbnode *))
{
if(p != nil) {
inord(p->left,nil,op);
(*op)(p);
inord(p->right,nil,op);
}
}

/ **************************************************
**************************/
/*procedura che serve alla visita ordinata del grafo rb, chiama specificando il nodo di partenza*/
void inorder(rbtree *p, void (*op)(rbnode *))
{
inord(p->root, p->nil, op);
}

Dunque, sto aiutando un amico a fare questo progetto....
Abbiamo utilizzato un albero di ricerca ordinato per Id, in questo modo quando stampiamo tutti i componenti sono già ordinati con la ricerca simmetrica, se stampo per famiglia eseguo sempre la ricerca simmetrica, se fa parte della famiglia allora stampo.
Manca solo il punto della linearità, l'esempio del docente (esempio 1) è chiaro in quanto da per scontato su quali ganci sono appesi i componenti, ma nel progetto non è chiaro su quali ganci collocare i componenti, esempio
l(2 7 17 24 26)
quale/i componente si trova sul gancio 2??????
qualche idea?

__________________
La Fede non retrocede mai!
Döma Atalanta!!!!!!!!

Originally posted by loreste
Dunque, sto aiutando un amico a fare questo progetto....
Abbiamo utilizzato un albero di ricerca ordinato per Id, in questo modo quando stampiamo tutti i componenti sono già ordinati con la ricerca simmetrica, se stampo per famiglia eseguo sempre la ricerca simmetrica, se fa parte della famiglia allora stampo.
Manca solo il punto della linearità, l'esempio del docente (esempio 1) è chiaro in quanto da per scontato su quali ganci sono appesi i componenti, ma nel progetto non è chiaro su quali ganci collocare i componenti, esempio
l(2 7 17 24 26)
quale/i componente si trova sul gancio 2??????
qualche idea?

e x la funzione ordina invece come fai? usi una lista d supporto?
xke devi cercare i componenti d cui nella funzione ordina ti da i codici identificativi e poi li devi stampare in ordine ma in base al costo..

l'albero rb sono più performanti nella ricerca, sai che nel caso peggiore ci metti 2 Log n, mentre nell'albero di ricerca i caso peggiore è n, detto questo è indifferente.
Per quanto riguarda l'ordina, creo un secondo albero temporaneo con i soli elementi di mio interesse (cosi non spreco ram).

__________________
La Fede non retrocede mai!
Döma Atalanta!!!!!!!!

ragazzi magari è l'ora ma ho un problema con la funzione ordina.
nel senso che non so quanti codici identificativi mi inserisce,
nella dichiarazione di funzione come fate cn i parametri? cosa mettete?

tanto che ci sono un'altra domandina:
x quanto riguarda le stampe voi avete fatto le due funzioni di visita in ordine a parte come c'è implementato in algoteam oppure visto la funzione inorder che semplicemente richiama la funzione ricorsiva inorder la chiamate direttamente da dentro la funzione stampa?!!?

grazie mille!!! Ripeto probabilmente sono cavolate, è ke l'ora d certo nn aiuta a ragionare..

Originally posted by carla86

...
infatti io domani mattina vado a ricevimento (gliel'ho chiesto via mail) proprio x capire bene sta situazione del lineare...
anke xke tra l'altro non ti da neanche quante posizioni sono, x cui come leggi tutte le posizioni per poi inserirle in qualche struttura?

sono da poco tornata a casa dall'uni.
il ricevimento del prof è durato 10 minuti.

praticamente ci siamo fatti più problemi che altro, siamo stati a cercare qualcosa d inesistente.
nella funzione lineare al prof aguzzoli basta che gli venga stampato un dispositivo lineare con estensione massima e ke rispetti quelle posizioni.
non fatevi ingannare dal file di output d'esempio, xke quello appunto è solo un esempio e nn ce nessun criterio x il quale abbia scelto quel dispositivo al posto dell'altro.
e anke le altre combinazioni di componenti ke sono cmq dispositivi lineari e rispettano le posizioni andavano bene.
praticamente loro ne hanno preso uno a caso tra tutti quelli lineari e noi dobbiamo fare lo stesso, ossia stampare un dispositivo lineare con estensione massima e ke ovviamente rispetti le posizioni date dagli argomenti della funzione.

invece chiedo a voi: come avete fatto per la funzione ordina ke ha numero di parametri arbitrari e nn si sa a priori?
grazie

Grazie per il post.
Ma non riesco a capire, l(2 7 17 24 26) i numeri sono i ganci, giusto?
Come faccio a sapere che a quelle posizioni siano presenti componenti? E quali componenti se in fase di creazione non viene specificata la posizione?
Probabilmente, come dici tu, è più semplice di quel che si pensi, però non riesco ad afferrare!!

allora, come anke mi ha detto il prof oggi, si hanno solo dei componenti, infatti nessuna funzione prima d lineare ti chiede d gestire o fare qualcosa con i dispositivi.

quando viene chiamata la funzione lineare hai una struttura dati con dei componenti e una serie d posizioni.
sei tu ke devi fare gli accoppiamenti componente, posizione in modo ke la lista d quest'ultimi formi un dispositivo lineare con xo' estensione massima.

ripeto invece la mia domanda come fate quando avete funzioni tipo ordina o tipo lineare in cui nn sapete quanti elementi avete?

non so a che punto siete voi, forse sono io ignorante, mettendo come presupposto che la chiave di ogni nodo è l'identificativo del componente, quando bisogna fare la ricerca in base alla famiglia del componente come fate? e sopratutto nella ricerca dei componenti lineari l'id nn serve proprio a nulla....
sono nel panico, datemi delucidazioni...

Per carla86
io ho implementato un albero di ricerca ordinato per ID, ho una funzione, che dato un ID mi restituisce il nodo, clono il nodo e creo un altro albero con tutti i nodi che mi interessano ordinandoli per costo, stampo i dati e distruggo il secondo albero

__________________
La Fede non retrocede mai!
Döma Atalanta!!!!!!!!

Originally posted by loreste
Per carla86
io ho implementato un albero di ricerca ordinato per ID, ho una funzione, che dato un ID mi restituisce il nodo, clono il nodo e creo un altro albero con tutti i nodi che mi interessano ordinandoli per costo, stampo i dati e distruggo il secondo albero

per esempio nella funzione componente sai quanti numeri devi leggere e quindi poi riesci a passare i dati alla funzione; ma nelle funzioni in cui nn sai quanti interi devi leggere come fate?
ah dimenticavo lo stesso problema si pone in lineare xke non so quante posizioni mi mette a priori...

Non ho una funzione ordina, ho una funzione che gli passi un albero (la radice) e lui stampa i nodi già ordinati....
quindi nel main ho

if carattero letto = s
inorder(albero1);

if carattero letto = o
costruisci il secondo albero;
inorder(albero2);

__________________
La Fede non retrocede mai!
Döma Atalanta!!!!!!!!

scusami se sono pignola...
io con la funzione ordina mi riferivo all'operazione che è stata chiesta nel testo. cmq credo d aver capito.
grazie

incontro un altro problema di input...come avete distinto tra il comando

s --> stampa()

s f --> stampa tutti quelli della famiglia

intendo proprio nella parte

case 's': /* stampa */

Scusa Carla,
cosa intendi per estensione massima?
Che tra tutti i componenti che formano dispositivi lineari, si sceglie il dispositivo con l'estensione massima?

cosa ci si inventa per la funzione lineare ?

ciao

Originally posted by BeppeGoal
Scusa Carla,
cosa intendi per estensione massima?
Che tra tutti i componenti che formano dispositivi lineari, si sceglie il dispositivo con l'estensione massima?

io non ho ancora capito cosa si intende con:

Esempio 2 Siano c1, c2 ......., c6 le componenti definite nell'Esempio 1. L'operazione: lineare (2; 7; 17; 24; 26)

può produrre uno dei due dispositivi seguenti, entrambi di estensione 25 + 12 + 24 + 8 = 69
(c5; 2; c1; 7; c3; 17; c6; 24) oppure (c5; 2; c2; 7; c3; 17; c6; 24):

__________________
Non ti perdere di coraggio se ti tocca lavorare molto e raccogliere poco.....

Originally posted by fa88bio
ciao a tutti...a quanto ho capito io la funzione lineare fissa la posizione dei componenti al momento della chiamata alla funzione stessa:::
l(2 7 17 24 26) significa che:
si ha a dispozizione 26-2=24 come lunghezza max del dispositivo;
il primo componente deve avere lunghezza <= di 7-2=5 unità;
il secondo <= 17-7=10 unità;
il terzo <=24-17=7 unità;
il quarto <=26-24 unità..
per questo motivo i dispositivi possono essere piu di uno e di questi si vuole stampare solo quello avente area totale maggiore....
Il problema appunto è ke se come primo componente ad esempio, nella struttura dati ce ne sono 4 che nn superano la lughezza, come secondo ce ne sono 6,ecc.....bisogna provare un numero abbastanza grosso di combinazioni per ottenere i dispositivi
il problema quindi è che quello di implementare un algoritmo che provi tutte le possibili combinazioni sui componenti

__________________
Non ti perdere di coraggio se ti tocca lavorare molto e raccogliere poco.....

se le prime coordinate che ti passa sono 2 e 7
il componente deve avere lunghezza massimo 5
tra quelli di lunghezza massimo 5 cerchi quello con area maggiore ...
"
non è chiaro però come possa esistere un dispositivo lineare non adeguato "

se ho anche solo un componente che si adatta ad uno dei ganci perchè non dovrebbe costruire un dispositivo ??
cioè
c 1 2 3 2 5
c 2 3 4 3 5

l 2 4 5

dovrebbe restituire
c 1 2 3 2 5

sembra invece dagli esempi che debba restituire
Non esiste componente adeguato

idee??

perfetto grazie

__________________
Non ti perdere di coraggio se ti tocca lavorare molto e raccogliere poco.....

mi sapete dire xke nelle visite simmetriche implementate dal prof, sia x quella dell'albero di ricerca sia per quelli dell'albero red-black, tra i parametri ce un puntatore a funzione ke poi nn viene usato da nessun'altra parte??

void inorder(searchtree *p, void (*op)(searchtree *))
{
if(p) {
inorder(p->left,op);
(*op)(p);
inorder(p->right,op);
}
}

e poi xke nella visita inorder per gli alberi red-black ci sono addirittura due funzioni? nn basta in order, passandogli al posto d un nodo qualsiasi, la radice dell'albero?

void inord(rbnode *p, rbnode *nil, void (*op)(rbnode *))
{
if(p != nil) {
inord(p->left,nil,op);
(*op)(p);
inord(p->right,nil,op);
}
}

void inorder(rbtree *p, void (*op)(rbnode *))
{
inord(p->root, p->nil, op);
}

io ho toccato il meno possibile evitando di eliminare quello che non è strattamente chiaro, al massimo viene passato un parametro che non viene usato in questa implementazione

ragazzi ma voi come avete risolto per l'input del comando "o" (ordina)?
non riesco proprio a creare un array di int che aumenti dimensione man mano che viene inserito un nuovo numero in input -.-'

altra domanda: ma quando un albero (creato magari per un'operazione momentanea) non mi serve più, come faccio esplicitamente a deallocarlo?

Per quanto riguarda la funzione lineare ho un paio di domande:
1) se non esiste una componente che stia nello spazio tra due ganci che si fa? Si lascia vuoto quello spazio oppure si stampa il messaggio di errore?

2) nell'esempio 2, come secondo componente mette c1 oppure c2 che hanno entrambi estensione 12....come mai non sceglie c3 che è più corto dei precedenti ma ha estensione maggiore (24)?

EDIT:
-------------
quindi come soluzione possibile dell'esempio 2 io metterei anche:
69: (<c5,2>,<c3,7>,<c1,17>,<c6,24> ) oppure
69: (<c5,2>,<c3,7>,<c2,17>,<c6,8> )

voi che dite?

Originally posted by Spr1gg4N
altra domanda: ma quando un albero (creato magari per un'operazione momentanea) non mi serve più, come faccio esplicitamente a deallocarlo?

__________________
Non ti perdere di coraggio se ti tocca lavorare molto e raccogliere poco.....

Originally posted by mark
bella domanda: io inizializzo banalmente il puntatore alla radice a NULL, purtroppo è una sporca che non dealloca la memoria

Originally posted by Spr1gg4N
mmm si potrebbe una soluzione...però prima cmq bisogna eliminare tutti i nodi altrimenti la memoria è cmq occupata.

__________________
Non ti perdere di coraggio se ti tocca lavorare molto e raccogliere poco.....

esatto.

Qualche idea sulla mia domanda riguardo la funzione lineare?
E' l'ultima cosa che mi manca per finire il progetto ma sono bloccato

Originally posted by Spr1gg4N
Per quanto riguarda la funzione lineare ho un paio di domande:
1) se non esiste una componente che stia nello spazio tra due ganci che si fa? Si lascia vuoto quello spazio oppure si stampa il messaggio di errore?

2) nell'esempio 2, come secondo componente mette c1 oppure c2 che hanno entrambi estensione 12....come mai non sceglie c3 che è più corto dei precedenti ma ha estensione maggiore (24)?

EDIT:
-------------
quindi come soluzione possibile dell'esempio 2 io metterei anche:
69: (<c5,2>,<c3,7>,<c1,17>,<c6,24> ) oppure
69: (<c5,2>,<c3,7>,<c2,17>,<c6,8> )

voi che dite?

Originally posted by Spr1gg4N

Qualche idea sulla mia domanda riguardo la funzione lineare?
E' l'ultima cosa che mi manca per finire il progetto ma sono bloccato

Originally posted by kalbiz
se ho anche solo un componente che si adatta ad uno dei ganci perchè non dovrebbe costruire un dispositivo ??
cioè
c 1 2 3 2 5
c 2 3 4 3 5

l 2 4 5

dovrebbe restituire
c 1 2 3 2 5

Originally posted by misterx
io ho toccato il meno possibile evitando di eliminare quello che non è strattamente chiaro, al massimo viene passato un parametro che non viene usato in questa implementazione

Originally posted by Spr1gg4N
ragazzi ma voi come avete risolto per l'input del comando "o" (ordina)?
non riesco proprio a creare un array di int che aumenti dimensione man mano che viene inserito un nuovo numero in input -.-'

Originally posted by Spr1gg4N
ragazzi ma voi come avete risolto per l'input del comando "o" (ordina)?
non riesco proprio a creare un array di int che aumenti dimensione man mano che viene inserito un nuovo numero in input -.-'

Originally posted by Spr1gg4N
Per quanto riguarda la funzione lineare ho un paio di domande:
1) se non esiste una componente che stia nello spazio tra due ganci che si fa? Si lascia vuoto quello spazio oppure si stampa il messaggio di errore?

2) nell'esempio 2, come secondo componente mette c1 oppure c2 che hanno entrambi estensione 12....come mai non sceglie c3 che è più corto dei precedenti ma ha estensione maggiore (24)?

EDIT:
-------------
quindi come soluzione possibile dell'esempio 2 io metterei anche:
69: (<c5,2>,<c3,7>,<c1,17>,<c6,24> ) oppure
69: (<c5,2>,<c3,7>,<c2,17>,<c6,8> )

voi che dite?

Originally posted by mark
sporca numero 2

usare la funzione inorder() per visitare tutto l'albero e usare nodedelete() o similare per eliminare tutti i nodi

infine eliminare la radice con NULL

ciao!!
qualcuno d voi ke ha implementato gli alberi di ricerca binaria e ha implementato anke la funzione di distruggere l'albero.
quando andate a compilare con -Wall e -ansi anke a voi da questo warning:

In function ‘distruggialbero’:
progetto.c:459: warning: suggest parentheses around assignment used as truth value

secondo voi da cosa è dovuto? vi copio la mia riga 459
while(p = cancella(p, p));

grazie

Originally posted by carla86
ciao!!
qualcuno d voi ke ha implementato gli alberi di ricerca binaria e ha implementato anke la funzione di distruggere l'albero.
quando andate a compilare con -Wall e -ansi anke a voi da questo warning:

In function ‘distruggialbero’:
progetto.c:459: warning: suggest parentheses around assignment used as truth value

secondo voi da cosa è dovuto? vi copio la mia riga 459
while(p = cancella(p, p));

grazie

grazie, ha funzionato mancavano una coppia di parentesi!!

sto impazzendo sull'ordinamento per costo...io mi ritrovo una lista su kiave id con dentro i componenti presi dall'albero. come faccio a ordinarli in base al costo? come avete fatto voi?

Originally posted by Guepe
sto impazzendo sull'ordinamento per costo...io mi ritrovo una lista su kiave id con dentro i componenti presi dall'albero. come faccio a ordinarli in base al costo? come avete fatto voi?

mi dite x favore come faccio a scrivere una funzione ke ritorna un'array d interi?

int *pos(lista *p, int nro)
{
int pos[nro];
/*faccio quello che devo fare*/
return pos;
}

può andare bene? se no com'è? grazie

Risolto!!ho abbandonato le liste e ho creato u nalbero nuovo e poi inorder fa tutto, rimane solo un problema....nn mi prende l'ultimo componente nella ricerca e nn so il perchè...bah continuo a far prove....

Originally posted by Guepe
Risolto!!ho abbandonato le liste e ho creato u nalbero nuovo e poi inorder fa tutto, rimane solo un problema....nn mi prende l'ultimo componente nella ricerca e nn so il perchè...bah continuo a far prove....

x la funzione lineare voi come fate? o meglio dopo aver letto le posizioni fate uno alla volta i componenti partendo da quello da mettere in prima posizione oppure partite da quello ke deve avere lunghezza minore..

mi spiego meglio con un esempio
l 2 7 17 24 26
partitè dal componente da mettere nella posizione due oppure partite dal componente da mettere in posizione 24 visto ke deve essere il più piccolo?

nel caso partite da quello più piccolo come fate?

proprio non riesco a farla andare sta funzione ordina.....mi stampa solo due valori dell'albero....non riesco a capire perke mi stampa solo la radice e il figlio sinistro cioe i componenti 24 e 7...

qualcuno ha fatto la funzione lineare?!?!

io mi sa ke sono fusa..
sono riuscita a leggere tutte le posizioni inseritemi cn il comando l e le ho memorizzate in una lista.
mi sono creata un'altro albero rb con i componenti ordinati per area (come da qualcuno suggerito).
ma ora nn so come calcolare, o meglio nn so dove memorizzare le distanze, ogni volta la distanza tra una posizione e la successiva x poter controllare ke il massimo ritornatomi dall'albero ordinato per area possa stare in quella posizione.

qualche idea??

Originally posted by carla86
qualcuno ha fatto la funzione lineare?!?!

io mi sa ke sono fusa..
sono riuscita a leggere tutte le posizioni inseritemi cn il comando l e le ho memorizzate in una lista.
mi sono creata un'altro albero rb con i componenti ordinati per area (come da qualcuno suggerito).
ma ora nn so come calcolare, o meglio nn so dove memorizzare le distanze, ogni volta la distanza tra una posizione e la successiva x poter controllare ke il massimo ritornatomi dall'albero ordinato per area possa stare in quella posizione.

qualche idea??

Non so dove sbaglio ma dopo tre ore mi sto per mangiare il pc!!
Carla nella funzione ordina per creare un albero nuovo inserendo i componenti con kiave c (costo) tu come hai fatto? Hai riscritto le funzioni di inserimento dei componenti nell'albero? Cosi facendo mi continua a ordinarli per id anche se nelle due funzioni la posizione dei nodi è definita dalle equazioni con il costo come paramentro.....nn capisco come sia possibile...

Originally posted by Guepe
Non so dove sbaglio ma dopo tre ore mi sto per mangiare il pc!!
Carla nella funzione ordina per creare un albero nuovo inserendo i componenti con kiave c (costo) tu come hai fatto? Hai riscritto le funzioni di inserimento dei componenti nell'albero? Cosi facendo mi continua a ordinarli per id anche se nelle due funzioni la posizione dei nodi è definita dalle equazioni con il costo come paramentro.....nn capisco come sia possibile...

Originally posted by Guepe
Non so dove sbaglio ma dopo tre ore mi sto per mangiare il pc!!
Carla nella funzione ordina per creare un albero nuovo inserendo i componenti con kiave c (costo) tu come hai fatto? Hai riscritto le funzioni di inserimento dei componenti nell'albero? Cosi facendo mi continua a ordinarli per id anche se nelle due funzioni la posizione dei nodi è definita dalle equazioni con il costo come paramentro.....nn capisco come sia possibile...

i confronti nelle due funzioni li faccio fare con il valore c passato e il valore del nodo gia presente e infatti funziona pero me ne stampa solo due:
nell'esempio del prof inorder mi da
24 1 2 3 3
7 3 4 6 2
ma il componente 23 nn lo stampa! son sicuro di averlo inserito nell'albero perke per precauzione mi son fatto fare una stampa dopo ogni inserimento.

Originally posted by Guepe
i confronti nelle due funzioni li faccio fare con il valore c passato e il valore del nodo gia presente e infatti funziona pero me ne stampa solo due:
nell'esempio del prof inorder mi da
24 1 2 3 3
7 3 4 6 2
ma il componente 23 nn lo stampa! son sicuro di averlo inserito nell'albero perke per precauzione mi son fatto fare una stampa dopo ogni inserimento.

Originally posted by mostrielo
Io ho usato degli array:

<< 2, 7, 17, 24, 26>> input

<< 2, 7, 17, 24>> : gancio
<< 5, 10, 7, 2>> : base (gancio[i+1] - gancio[i])
<<null,null,null,null>> : puntatori a Componente

ho un'altra domanda, una volta ke mi sono fatta dare il massimo dall'albero in cui ci sn i nodi ordinati per area quale tra queste due funzioni mi da il suo precedente?
nodorb *treesucc(alberorb *r, nodorb *q)
{
nodorb *qq;
if(q->f_destro != r->sentinella)
return rbtmin(q->f_destro,r->sentinella);
qq = q->padre;
while(qq != r->sentinella && q == qq->f_destro) {
q = qq;
qq = qq->padre;
}
return qq == r->sentinella ? NULL : qq;
}

nodorb *treepred(alberorb *r, nodorb *q)
{
nodorb *qq;
if(q->f_sinistro != r->sentinella)
return rbtmax(q->f_sinistro,r->sentinella);
qq = q->padre;
while(qq != r->sentinella && q == qq->f_sinistro) {
q = qq;
qq = qq->padre;
}
return qq == r->sentinella ? NULL : qq;
}

a logica vi direi treepred ma siccome in qst momento nn sono sicura d nulla ve lo chiedo..

altra domanda:
come si stampa un array di puntatori a una struttura nodo di un albero red-black?
a sto punto nn è più semplice che i componenti li si mettano in una lista a parte con solo le caratteristiche invece che come puntatori a una struttura?

un'altra cosa ke nn mi quadra.

nodorb inserimento_area(alberorb *albarea, int i, int f, int c, int l, int h)
{
nodorb *q = malloc(sizeof(nodorb));
nodorb *r = albarea->radice;
nodorb *s = albarea->sentinella;
int area;
if(!q)
{
fprintf(stderr,"Errore di allocazione del nodo.\n");
exit(-5);
}
q->codice_identificativo = i;
q->famiglia = f;
q->costo = c;
q->lunghezza = l;
q->altezza = h;
area = (l*h);
q->estensione = area;
q->f_sinistro = q->f_destro = albarea->sentinella;
q->colore_nodo = red;
while(r != albarea->sentinella)
{
s = r;
r = (l*h) < r->estensione ? r->f_sinistro : r->f_destro;
}
q->padre = s;
if(s == albarea->sentinella)
return albarea->radice = q;
if((l*h) < s->estensione)
s->f_sinistro = q;
else
s->f_destro = q;
return q;
}

xke mi da questo errore:

426: error: incompatible types in return
progetto2.c:431: error: incompatible types in return
progetto2.c:432: warning: control reaches end of non-void function

la riga 426 è: return albarea->radice = q;
la riga 431 è: return q;

se qualcuno capisce il perchè... io nn ci riesco un po xke sono fusa e un po xke sono nervosa ke nn so come fare lineare...
argh nn posso nn consegnare solo x una funzione maledetta!!!

ps da notare ke sull'altra funzione di inserimento praticamente identica va tutto bene, su questa ke mi serve per l'albero delle aree no... uffa!!!

Originally posted by carla86
un'altra cosa ke nn mi quadra.

nodorb inserimento_area(alberorb *albarea, int i, int f, int c, int l, int h)
{
nodorb *q = malloc(sizeof(nodorb));
nodorb *r = albarea->radice;
nodorb *s = albarea->sentinella;
int area;
if(!q)
{
fprintf(stderr,"Errore di allocazione del nodo.\n");
exit(-5);
}
q->codice_identificativo = i;
q->famiglia = f;
q->costo = c;
q->lunghezza = l;
q->altezza = h;
area = (l*h);
q->estensione = area;
q->f_sinistro = q->f_destro = albarea->sentinella;
q->colore_nodo = red;
while(r != albarea->sentinella)
{
s = r;
r = (l*h) < r->estensione ? r->f_sinistro : r->f_destro;
}
q->padre = s;
if(s == albarea->sentinella)
return albarea->radice = q;
if((l*h) < s->estensione)
s->f_sinistro = q;
else
s->f_destro = q;
return q;
}

xke mi da questo errore:

426: error: incompatible types in return
progetto2.c:431: error: incompatible types in return
progetto2.c:432: warning: control reaches end of non-void function

la riga 426 è: return albarea->radice = q;
la riga 431 è: return q;

se qualcuno capisce il perchè... io nn ci riesco un po xke sono fusa e un po xke sono nervosa ke nn so come fare lineare...
argh nn posso nn consegnare solo x una funzione maledetta!!!

ps da notare ke sull'altra funzione di inserimento praticamente identica va tutto bene, su questa ke mi serve per l'albero delle aree no... uffa!!!

Originally posted by carla86
scusami ma hai usato degli array gia dall'inizio quando hai letto l'input oppure con l'input letto e messo in un'altra struttura (tipo io l'ho messo in una lista) hai costruito i tre array?
l'ultimo array sarebbero dei puntatori ai nodi dell'albero giusto?

Originally posted by mostrielo
Ho letto l'input e l'ho messo in un array; poi ho creato i due array ausiliari: distanze tra ganci e puntatori a Componente.
Durante la visita dell'albero di predecessore in predecessore, all'ultimo array, se la lunghezza del rettangolo è <= della distanza tra i ganci, viene assegnato il campo Componente del nodo (max corrente); per stampare i componenti il dispositivo basta un ciclo su questo array.

ke palle sono completamene bloccata!
e la cosa ke mi fa andare in bestia è ke ora ho
- una lista con le posizioni (so ke è giusta xke l'ho stampata).
- una lista con le distanze tra le posizioni (so ke è giusta xke l'ho stampata).
- l'albero rb ordinato per area...
e ora nn so come mettere in pratica il ragionamento ke in testa ce!!!
uff ke nervoso!!

ma voi l'avete finito?? a che punto siete??

Allego un file di input e il relativo output: potete controllare con i vs. exe?

In quanti son riusciti a consegnarlo entro ieri?
mi direste ke strutture avete usato alla fine?
Grazie

Io ho consegnato ieri e ho utilizzato solo RB alberi e liste concatenate

Sapete per caso se la data di esposizione del progetto la pubblicheranno qui ( http://homes.dsi.unimi.it/~aguzzoli/algo.htm ) oppure da qualche altra parte?

Originally posted by Spr1gg4N
Io ho consegnato ieri e ho utilizzato solo RB alberi e liste concatenate

Scusate ma secondo voi, ammesso di aver passato il progetto ed essere ammessi all'orale, quando sarà indicativamente il colloquio? Questa o la prossima settimana? Di solito quanti giorni passano?

Qualcuno che non è riuscito a consegnare il progetto l'8 sta tentando di consegnarlo il 24?
Per la funzione estensione c'è da implementare un modello matematico che calcola l'unione delle estensioni dei componenti che non è difficile...di più.
Per ora con un mio amico siamo riusciti a capire il funzionamento di quando ci sono due componenti che si sovrappongono, il problema si crea quando ci si scontra con una sovrapposizione multipla....

Forse è una domanda stupida ma mi è venuto un dubbio.
Quando dice che il programma deve leggere da standard input stdin
e scrivere su standard output, vuol dire che il prof testerà il programma eseguendolo cosi:

componentielettroniche < stdin.txt >stdout.txt

o dobbiamo noi usare solo fscanf e fprintf in modo da farglielo leggere e scrivere direttamente senza che gli dia l'input e l'output?

standard input = tastiera (ma ovviamente lo farà con la redirezione dell'input)

standard output = video

vorrei usare l'implementazione del prof degli alberiRB, ma non riesco a capire (C non e' il mio forte) cosa passare come terzo argomento in un eventuale main di prova alla funz inorder.
qualcuno puo' illuminarmi?

void inord(rbnode *p, rbnode *nil, void (*op)(rbnode *))

{

if(p != nil) {

inord(p->left,nil,op);

(*op)(p);

inord(p->right,nil,op);

}

}



void inorder(rbtree *p, void (*op)(rbnode *))

{

inord(p->root, p->nil, op);

}

Originally posted by kermit63
vorrei usare l'implementazione del prof degli alberiRB, ma non riesco a capire (C non e' il mio forte) cosa passare come terzo argomento in un eventuale main di prova alla funz inorder.
qualcuno puo' illuminarmi?

void inord(rbnode *p, rbnode *nil, void (*op)(rbnode *))

{

if(p != nil) {

inord(p->left,nil,op);

(*op)(p);

inord(p->right,nil,op);

}

}



void inorder(rbtree *p, void (*op)(rbnode *))

{

inord(p->root, p->nil, op);

}

grazie carla86!
finalmente ho capito come funziona il passaggio di parametri funzione

Ma qualcuno che sta dando il progetto il 24???
Sto impazzendo un po sulla funzione prospetto perché non so in che struttura dati inserire il prospetto visto che poi la funzione costominimo dovrà lavorarci e non poco....voi che avete usato?

progetto del 24 ?!

Io devo dare il progetto del 24 ma sto letteralmente impazzendo per la creazione della funzione "costominimo" qualcuno ha da dare suggerimenti ? sono ben Accetti!!!



Prima mia ipotesi creare TUTTE le combinazioni possibili e prendere quella con costo minore.. Dobrebbe dare un risultato corretto ma il prof ha detto che nn è Ottimale..

Seconda utilizzare Programmazione dinamica ? quale soluzione verrebbe fuori ? cmq sia la ricorsione nn andrebbe a fare la combinazione cmq di tutti i casi ?

suggerimento per il costominimo:
io uso un grafo pesato, con nodi pari agli elementi del prospetto. ad ogni nodo aggiungo la sua lista di nodi adiacenti, prendendoli dal gruppo successivo nel prospetto e calcolando il peso del cammino. il peso e' dato dalla somma dei costi dei due nodi + l'eventuale costo della famiglia di destinazione se le famiglie sono diverse. ottenuto il grafo pesato calcolo il cammino minimo da ogni sorgente (saranno pochi) e nel caso sia minore del precedente lo sostituisco.
l'unico problema e' che devo ancora implementarlo.. aiuto !!

per il cammino minimo usero' Dijkstra, ovviamente

+ o - ho capito come fai tu..
o come farai .. penserò ancora un pò e poi vedo che fare.