Prova di Algoritmi e s.d. (1o anno) 7 Febbraio TESTO e RISPOSTE

Transcript

1 Prova di Algoritmi e s.d. (1o anno) 7 Febbraio 2003 TESTO e RISPOSTE Esercizio 1 (punti 5 in prima approssimazione) Consideriamo alberi binari con insieme dei nodi NODI = N (l'insieme dei naturali). Riportiamo qui sotto la definizione induttiva di tali alberi contenuta nelle dispense Def_3 L insieme degli alberi binari su NODI, che indichiamo con BinTree(NODI), e per ciascun albero t: l insieme dei suoi nodi, Nodi(t), la radice, root(t), la relazione padre-figli sono definiti induttivamente da: base: ^ Œ BinTree(NODI) inoltre Nodi( ( ^ ) ) = passo se n Œ NODI ; t 1, t 2 Œ BinTree(NODI) e Nodi(t 1 ) «Nodi(t 2 ) = e n œ Nodi(t 1 )» Nodi(t 2 ) allora ( n, < t 1, t 2 > ) Œ BinTree(NODI) inoltre, se usiamo t per indicare ( n, < t 1, t 2 > ) : root(t) = n ; Nodi(t) = {n» Nodi(t 1 )» Nodi(t 2 ) ; se t 1 ^ allora root(t 1 ) è il figlio sinistro di n; se t 2 ^ allora root(t 2 ) è il figlio destro di n. Su questi alberi, definiamo, per induzione la funzione ff : BinTree( NODI ) Æ N ff ( (n, < t1, t2>) ) = n + ff ( t1 ) + ff ( t2 ) se t1 ^ e t2 ^ ff ( t ) = 0 altrimenti Consideriamo l'albero tt disegnato nel foglio seguente Domande: a) (1 punto) scrivere l'albero tt sotto forma di espressione, secondo la definizione induttiva, cioè usando (, ), <, > b) (2 punti) quanto vale ff( tt )? c) (2 punti) disegnare tt nella forma : figlio sinistro - fratello destro Albero tt:

2 Risposte a) tt = ( 3, < t1, t2 > ) dove t1 = ( 2, < (1, <^, ^>), ( 5, < (4, <^, ^>), ^ > ) > ) t2 = ( 7, < (6, <^, ^>), ( 9, <( 8, <^, ^>), ^ > ) > ) b) ff( tt ) = 12 c) Esercizio 2 (punti 5 in prima approssimazione i punti sono poi diventati 4) Consideriamo le seguenti dichiarazioni: typedef struct nodo * Alb; struct nodo { int info; Alb sin, des; ; void stampa_1 (Alb) ; void stampa_2 (Alb) ; void stampa (Alb a) { if (a!= NULL) { stampa_1 (a->sin); printf ( " %d ", a->info ); stampa_2 (a->des); void stampa_1 (Alb a) { if (a!= NULL) { printf ( " %d ", a->info ); stampa_1 (a->sin); stampa_1 (a->des); 2

3 void stampa_2 (Alb a) { if (a!= NULL) { stampa_2 (a->des); stampa_2 (a->sin); printf ( " %d, ", a->info ); Domanda: qual'è l'output della chiamata stampa(a) se A è ( il puntatore al ) l'albero tt disegnato sopra? Risposta : Esercizio 3 (punti 11 in prima approssimazione poi diventati 12 ) Consideriamo il tipo di dato "successioni di caratteri ", con le seguenti caratteristiche: lunghezza illimitata i caratteri sono dati da un insieme CAR e con le operazioni seguenti: empty : la successione vuota is-empty : is-empty( s ) = " s è la successione vuota? " add : add ( <c1,..., ck>, c ) = < c1,..., ck, c > rest: rest( <c1,..., ck> ) = <c2,..., ck> se k >0 rest non è definita sulla successione vuota Per l'implementazione di questo tipo di dato utilizziamo liste circolari : la succ vuota è implementata con un puntatore nullo le liste non vuote sono fatte come le liste solite, ma: il puntatore "principale" (quello che permette di accededere alla lista), punta all'ultimo record della lista; il puntatore "next" di questo record punta al primo elemento della lista... vedere la figura che rappresenta due successioni: <a, b, c> e < a > a b c a 3

4 Domande a) (2 punti poi diventati 3) precisare quali sono le sorti di questo tipo di dato (scegliere dei nomi ragionevoli), precisando, per ciascuna sorte, l'insieme corrispondente b) (1 punti) Precisare (in C o pseudocodice) i tipi necessari per l'implementazione del tipo di dato usando liste circolari; per i caratteri va bene il tipo char predefinito ; c) (4 punti) Scrivere (in modo coerente alla parte b) una implementazione dell'operazione add, precisando anche come viene utilizzata nel programma principale d) (4 punti) Scrivere (in modo coerente alla parte b) una implementazione dell'operazione rest, precisando anche come viene utilizzata nel programma principale Risposte a) sorte ch succ insieme CAR CAR * (= insieme delle succ finite su CAR) bool { vero, falso NOTA: le sorti, ed i relativi insiemi, si riferiscono esclusivamente al tipo di dato; è escluso qualunque riferimento all'implementazione!!! Per capire quali sono le sorti in gioco, basta guardare le operazioni: servono tutte e sole le sorti che corrispondono agli argomenti e ai risultati delle operazioni. b), c), d) in pseudocodice. NOTA: L'implementazione delle operazioni si può fare con funzioni, oppure con procedure. Per segnalare in modo pulito il tentativo di prendere il resto della succ vuota, la cosa piu' semplice e` realizzare l'operazione rest con una procedura; allora, per uniformitaà, è sensato fare la stessa cosa con la add. a) type C_list = puntatore_a_nodo Nodo = record { info : char, next : C_list b) procedura add ( s : C_list IN-OUT, c : char : IN ) { var aux : C_list new (aux) ; aux->info c ; if s = NULL then aux->next aux else { aux->next s->next, s->next aux s aux la procedura si usa nel modo piu' ovvio: se voglio aggiungere cc in fondo alla succ ss 4

5 uso l'istruzione add ( ss, cc ) NOTA In C, si e` costretti ad usare, come primo argomento, non s di tipo C_list, ma pun_s di tipo puntatore a C_list... La maggior parte delle persone, in questo caso, pasticcia (e perde punti)... Continuo a non capire perchè le persone si ostinino a scrivere in C, pur conoscendolo poco... c) procedura rest ( s : C_list IN-OUT, err : bool : OUT ) { var aux : C_list if s = NULL then err true else { err false if s = s->next lista con un solo elemento... then { dispose ( s ) ; s NULL else { aux s->next aux punta al primo della lista s->next aux->next dispose ( aux ) la procedura si usa nel modo seguente: se voglio il resto della succ ss uso l'istruzione una var booleana errore; chiamo la procedura: rest ( ss, errore) se poi errore = vero, allora..., altrimenti... Per il C: come sopra, solo che qui anche il secondo argomento deve essere un puntatore. Esercizio 4 (punti 9 in prima approssimazione) Nelle procedure che seguono i tipi sono: Alb è un puntatore_a_nodo Nodo = record info : intero left, right : Alb end function conta ( t : Alb ) : integer istruzioni: if t = NULL then return ( 0 ) else return ( 1 + conta ( t->left) + conta (t->right) ) function bil ( t : Alb ) : integer istruzioni: if t = NULL then return ( 0 ) else return ( valore_assoluto_di ( conta ( t->left) - conta (t->right) ) ) function recbil ( t : Alb ) : integer istruzioni: if t = NULL then return ( 0 ) else { scrivi ( bil (t) ; recbil ( t->left) ; recbil (t->right) 5

6 Domande. a) (punti 1) qual'è il risultato di bil( tt ) se tt è l''albero nella figura precedente b) (punti 2) determinare la complessità della generica chiamata conta( t ) (nel caso peggiore) in funzione del numero di nodi dell'albero, sia n c) (punti 2) determinare la complessità della generica chiamata bil ( t ) (nel caso peggiore) in funzione del numero di nodi dell'albero, sia n d) (punti 4) determinare la complessità della generica chiamata recbil ( t ) (nel caso peggiore) in funzione del numero di nodi dell'albero, sia n Possibilmente dare stime in Q(... ). Non fare conti troppo dettagliati (esplicitando tutte le costanti,...), ma non limitarsi nemmeno a dare il risultato, o a quattro chiacchere; in particolare, precisare se c'è un caso peggiore (o caso pessimo) e qual'è. Risposte a) bil( tt ) = 0 b) il passaggio dei parametri ha costo costante; anche l'esecuzione del corpo, tolte le chiamate ricorsive, è a costo costante; l'albero delle chiamate ha la stessa forma dell'albero t, ma con un "livello" in piu' creato dalle chiamate sull'albero vuoto; queste chiamte sono circa n; non esiste un caso peggiore; per ogni nodo dell'albero delle chiamate abbiamo un costo costante; quindi il costo è in Q( n ). c) il passaggio dei parametri ha costo costante; anche l'esecuzione del corpo è a costo costante, tranne le due chiamate alla funzione conta; 1a chiamata su albero con p nodi; costo ap + c 2a chiamata su albero con q nodi, costo aq + b con p+q = n-1 quindi il costo totale è in Q( n ). Anche qui non esiste caso peggiore. d) fatto in dettaglio, in modo da capire qual'è il caso peggiore... Tutto a costo costante, tranne le chiamate ricorsive e l'istruzione scrivi ( bil ( ) ); l'albero delle chiamate ha la stessa forma dell'albero t (con un livello in più corrispondente alle chiamate sull'albero vuoto, come sopra; queste chiamate hanno un costo costante). Ad ogni nodo interno (= non foglia) dell'albero delle chiamate, il costo è determinato da scrivi ( bil ( ) ) il cui costo è proporzionale al numero di nodi "che stanno sotto".... Nel caso di albero bilanciato, la sutuazione è del tipo: albero chiamate (stilizzato): costi scrivi su n nodi an + b 2 VOLTE scrivi su (n-1)/2 nodi a n + b (al più) 4 VOLTE scrivi su (n-3)/4 nodi a n + b (al più) eccetera 6

7 poichè l'albero è bilanciato, l'altezza è log n; quindi il costo di tutto è in O( n log n) Nel caso di albero totalmente sbilanciato, ragionando in modo analogo a sopra, abbiamo un costo del tipo: (a n + b) + (a(n-1) + b) + (a(n-2) + b) + (a(n-2) + b) (a + b) + c cioè: a  (k= n, n-1,...1) k + b  (k = n, n-1,...1) 1 + c = a (n (n+1)/2) + b n + d Dunque: c'è un caso peggiore: albero totalmente sbilanciato; la complessità, nel caso peggiore è in Q( n 2 ). 7