Algoritmi e strutture dati 16 Dicembre 2004 Canali A L e M Z Cognome Nome Matricola

Transcript

1 Algoritmi e strutture dati 16 Dicembre 04 Canali A L e M Z Cognome Nome Matricola Problema 1 (6 punti) Determinare la funzione calcolata dal metodo mistero e la sua complessità computazionale in funzione del valore n e della dimensione dell input. public static int mistero(int n) { int f = 1; int g = 1; int c = 2; while(g < n) { int k = f + g; f = g; g = k; c++; return c; PRECISAZIONE Durante lo svolgimento del compito d esame è stato precisato che occorre determinare due funzioni distinte: 1. la complessità computazionale in funzione del valore n; 2. la complessità computazionale in funzione della dimensione dell input. La condizione di terminazione del ciclo è espressa in termini della variabile g: studiamo dunque la successione dei valori che g assume nel corso delle iterazioni. Simulando alcune iterazioni otteniamo la seguente successione: 1, 2, 3, 5,,, 21, in cui si riconosce subito la successione dei numeri di Fibonacci. Diamone ora la dimostrazione formale. Siano f i e g i i valori assunti da f e g all inizio dell i-esima iterazione. Osservando che g i+1 = f i + g i, e che f i+1 = g i (ossia f i = g i-1 ), risulta: g i+1 = g i + g i-1. (1) Le condizioni iniziali sono: g 1 = 1, f 1 = 1; definendo per comodità g 0 = f 1: g 0 = 1, g 1 = 1. (2). Le equazioni (1) e (2) sono proprio le equazioni dei numeri di Fibonacci: per la precisione, g i è l (i+1)-esimo numero di Fibonacci. Ora possiamo rispondere alla prima domanda. La variabile c conta quante iterazioni sono eseguite + 2. Sono eseguite delle iterazioni finché g i si mantiene minore di n (ossia finché g c +1 < n). Quando usciamo dal ciclo, dunque, g c +1 è il primo numero di Fibonacci strettamente maggiore di n. Il valore restituito, c, rappresenta il numero di numeri di Fibonacci minori o uguali a n. Occupiamoci ora della complessità. Dalla teoria è noto che il numero di numeri di Fibonacci minori o uguali a n è Θ(log n): sono quindi eseguite Θ(log n) iterazioni, ciascuna di costo costante. La complessità di mistero in funzione di n risulta essere Θ(log n). Per finire, la dimensione dell input è il minimo numero di bit x sufficienti a rappresentare l input. Poiché x = Θ(log n), ossia n=θ(2 x ), la complessità risulta: Θ(log 2 x ) = Θ(x). Pagina 1 di 6

2 Problema 2 (6 punti) Dato un albero binario di ricerca t, si descriva una rappresentazione java dell albero ed un metodo che permettano di determinare l i-esimo elemento memorizzato nell albero con costo computazionale limitato dalla profondita dell albero. Premessa: chiariamo bene una cosa che dovrebbe essere ovvia. L i-esimo elemento non è né l elemento con chiave i, né l elemento che è stato inserito per i-esimo nel BST! Invece, sulle chiavi del BST è definita una relazione d ordine totale. L i-esimo elemento è l elemento la cui chiave è i-esima secondo tale relazione d ordine. Il primo elemento è quello con chiave più piccola in assoluto, il secondo ha la chiave immediatamente più grande del primo, e così via. Ed ora l algoritmo. Supponiamo di voler cercare l i-esimo elemento in un albero con radice r. Poiché tutti gli elementi del sottoalbero sinistro di r hanno chiave minore di quella di r: Se il sottoalbero sinistro ha almeno i elementi, allora l i-esimo elemento si trova nel sottoalbero sinistro di r: continueremo la ricerca lì; Se il sottoalbero sinistro ha esattamente i-1 elementi, allora l i-esimo elemento si trova proprio nella radice r, in quanto il sottoalbero destro ha chiavi maggiori di quella della radice: restituisco la chiave della radice; Se il sottoalbero sinistro ha k elementi dove k < i - 1, allora l i-esimo elemento non è né nel sottoalbero sinistro di r, né in r (che contiene il (k+1)-esimo elemento). L elemento è contenuto nel sottoalbero destro. In particolare, considerando che i primi k+1 elementi dell albero si trovano nel figlio sinistro (k) e nella radice (1), l i-esimo elemento dell albero di radice r sarà l (i - (k+1))-esimo elemento del sottoalbero destro di r. In questo modo possiamo trovare l i-elemento di un albero di radice r scendendo direttamente verso l elemento richiesto. Il costo è proporzionale all altezza dell albero, a patto di inserire nella rappresentazione di ogni nodo x un informazione richiesta dall algoritmo: il numero di elementi del sottoalbero con radice x. La rappresentazione Java del BST diventa (si assumano chiavi intere): public class BSTNode { public BSTNode leftchild, rightchild; public int key; public int dim; //numero di elementi dell albero Implementiamo l algoritmo in forma ricorsiva, che in questo caso è la più naturale, elegante e compatta (si noti che si tratta solo di tradurre in codice quello che abbiamo espresso in lingua corrente): public static void findorder(bstnode root, int order) { if(root==null) return null; if(root.leftchild.dim >= i) return findorder(root.leftchild, order); else if(root.leftchild.dim == i-1) return root.key; else return findorder(root.rightchild, order - (root.leftchild.dim + 1)); Pagina 2 di 6

3 Problema 3 (6 punti) Illustrare graficamente lo stato di un BST bilanciato (AVL o red-black, a scelta), inizialmente vuoto, in seguito allo svolgimento delle seguenti operazioni. INS(), INS(), INS(), INS(), INS(), DEL(), INS(25) Illustriamo lo stato di un AVL in seguito allo svolgimento delle operazioni indicate. Operaz. Illustrazione Note INS() INS() INS() Sbilanciamento 2 del nodo : caso DS (doppia rotaz.). a) rotaz. sinistra di b) rotaz. destra di INS() INS() Sbilanciamento 2 del nodo : caso DS (doppia rotaz.). a) rotaz. sinistra di b) rotaz. destra di Pagina 3 di 6

4 DEL() Sbilanciamento +2 del nodo : rotaz. semplice sinistra del nodo (vedi slide AVL pag. 24 caso d) e) f)) INS(25) 25 Pagina 4 di 6

5 Problema 4 (6 punti) Dato un grafo diretto con archi non pesati, scrivere lo pseudocodice di un algoritmo che determina se esiste un nodo a distanza k da un nodo origine s. Eseguiamo una visita in ampiezza del grafo a partire dal nodo di origine s, tenendo conto del livello dei nodi attualmente visitati. Il livello di un nodo è la sua distanza da s. Pertanto esiste un nodo a distanza k se e solo se l algoritmo visita i nodi di livello k. class IndicatoreFineLivello { public static boolean esistenododistante(digraph G, Node s, int k) { int livello; Queue coda=new Queue(); //Questo è un oggetto speciale che inseriamo nella coda per indicare //che il livello attuale è stato completamente visitato IndicatoreFineLivello finelivello=new IndicatoreFineLivello(); for each Node n in G.nodes n.mark = false; livello = 0; s.mark = true; coda.enqueue(s); //Il nodo di origine è l unico nodo a livello 0, poi il livello è finito coda.enqueue(finelivello); while(!coda.isempty()) { Object obj=coda.dequeue(); if(obj == finelivello) //il livello è finito if(!coda.isempty()) { // e ce ne è almeno un altro da visitare coda.enqueue(finelivello); livello++; if(livello == k) return true; else { //il livello non è finito: obj è il prossimo nodo da visitare Node n = (Node) obj; for each Node m in n.successors if(!m.mark) { m.mark = true; coda.enqueue(m); return false; //non abbiamo raggiunto il livello k Pagina 5 di 6

6 Problema 5 (6 punti). Dato lo pseudocodice dell Algoritmo di Dijkstra per il calcolo dei cammini minimi in un grafo, modificarlo per ottenere l Algoritmo di Prim per il Minimum Spanning Tree. Discutere la complessita computazionale dell algoritmo di Prim. DijkstraAlg(grafo digraph, vertice source) for tutti i vertici v dist(v)= ; dist(source)=0; R = tutti i vertici; while R!=Ø v = vertice in R con minimo dist(v); for tutti i vertici u in R adiacenti a v if dist(u)>dist(u)+d(v,u) dist(u)= dist(u)+d(v,u); pred(u) = v; DijkstraAlg(grafo digraph, vertice source) for tutti i vertici v dist(v)= ; dist(source)=0; R = tutti i vertici; while R!=Ø v = vertice in R con minimo dist(v); for tutti i vertici u in R adiacenti a v if dist(u)>dist(v)+d(v,u) dist(u)= dist(v)+d(v,u); pred(u) = v; Discutiamo la complessità computazionale dell algoritmo di Prim. Refusi nel testo: dist(u) (> =) dist(v)+d(v,u) PrimAlg(grafo digraph, vertice source) 1 for tutti i vertici v 2 dist(v)= ; 3 dist(source)=0; 4 R = tutti i vertici; 5 while R!=Ø 6 v = vertice in R con minimo dist(v); 7 for tutti i vertici u in R adiacenti a v if dist(u) > d(v,u) 9 dist(u) = d(v,u); 10 pred(u) = v; Rappresentiamo l insieme R tramite uno heap: in questo modo potremo effettuare le operazioni di estrazione di nodo a distanza minima (6) e la riduzione della chiave (9) in tempo logaritmico rispetto al numero di elementi dello heap, che è limitato da V. Poiché il ciclo while (5-10) è ripetuto una volta per ogni vertice del grafo, e ogni volta si estrae il minimo dallo heap, una delimitazione inferiore al costo è Ω( V log V ). Complessivamente sono eseguite tante iterazioni del ciclo for (7-10) quanti sono gli archi del grafo (se il grafo è orientato; se il grafo è non-orientato, invece, sono eseguite complessivamente 2 E iterazioni for). Poiché, nel caso peggiore, ogni iterazione comporta una operazione di riduzione di chiave nello heap, il costo delle operazioni del ciclo for è O( E log V ). Pertanto la complessità computazionale complessiva dell algoritmo di Prim è O(( V + E ) log V ). Poiché il grafo è connesso (per precondizione), E V - 1, e quindi il costo si può scrivere semplicemente O( E log V ). Pagina 6 di 6