Compito di Algoritmi e Strutture Dati - B

a.a. 2018/2019
Appello 12/06/2019

1. Supponendo per semplicità che n sia una potenza di 2 e sapendo che

', #=1
!(#) = & #
2! + , + #, #>1
2
Risolvere la relazione di ricorrenza con i seguenti metodi:
a. Teorema Master;
b. Metodo dell’iterazione;
c. Metodo della sostituzione (usando i risultati di cui al punto a/b).

2. Si consideri un albero AVL per la memorizzazione di oggetti con chiave intera inizialmente vuoto. Mostrare
l’albero che si ottiene dopo ciascuno delle seguenti operazioni (commentare opportunamente il modo in cui si è
pervenuti al risultato mostrato):
a. Inserisci(19)
b. Inserisci(13)
c. Inserisci(16)
d. Inserisci(15)
e. Inserisci(14)
f. cancella(15)

3. Progettare una classe che permetta di enumerare iterativamente tutti i possibili cammini di un albero binario. La
classe deve prevedere un metodo hasNext() che restituisce True se ci sono ancora cammini e False altrimenti.
Inoltre, la classe deve avere un metodo next() che restituisce un cammino nell’albero. In tal modo, attraverso un
ciclo while, sarà possibile enumerare uno ad uno tutti i cammini dell’albero. Prevedere, all’interno della classe,
tutte le possibili strutture dati necessarie per il funzionamento del metodo next() e la ricostruzione iterativa dei
cammini. Se lo si reputa opportuno, prevedere un costruttore/metodo di inizializzazione.
Es.: considerando l’albero in figura, usando i metodi hasNext()/next() sarà possibile ottenere i seguenti cammini:
ABCD, ABD, AEAF
Es.

B E

C D A

F
D

4. Descrivere brevemente le tecniche note per la rappresentazione in memoria di grafi orientati e comparare i costi
computazionali delle operazioni di inserimento di un nodo, inserimento di un arco, cancellazione di un nodo e
cancellazione di un arco per le varie tecniche considerate.

5. Data la seguente matrice, che descrive i pesi degli archi di un grafo, calcolare l’albero dei cammini minimi.
1 2 3 4 5 6
1 0 9 2 Inf Inf Inf
2 Inf 0 Inf 1 3 Inf
3 Inf 1 0 Inf 5 Inf
4 Inf 1 Inf 0 Inf 4
5 Inf Inf Inf 1 0 2
6 inf Inf Inf Inf Inf 0
 Compito di Algoritmi e Strutture Dati - B
a.a. 2018/2019 Appello 26/06/2019

1. Supponendo per semplicità che n=2k e che k=2d, risolvere la seguente relazione di ricorrenza
', #=1
!(#) = &
√#!+√#, + #, #>1

2. Si consideri una coda con priorità implementata per mezzo di un heap binomiale. Supponendo che la coda sia
inizialmente vuota, mostrare l’heap binomiale che si ottiene dopo ciascuna delle seguenti istruzioni (commentare
opportunamente il modo in cui si è pervenuti al risultato mostrato):

a. Insert(“O”, 11 ) e. findMin()
b. Insert(“P”, 9) f. Insert(“A”, 12)
c. Insert(“F”, 8) g. DecreaseKey(“O”,5)
d. Insert(“D”, 10) h. Insert(“K”, 13)
i. deleteMin()

3. Progettare un algoritmo che, data in input una matrice A di dimensione NxN con valori binari (0 o 1), pre-processa
la matrice in modo da rispondere in tempo O(1) a successive interrogazioni restituendo True se tutti elementi di
una qualsiasi sotto-matrice di A hanno valore 1 e False altrimenti.
a. Fornire lo pseudo-codice dell’algoritmo di pre-processing e dell’algoritmo per le successive interrogazioni.
b. Determinare il costo computazionale dell’algoritmo di pre-processing.
c. Fornire lo pseudo-codice di un algoritmo che permetta di modificare un valore della matrice A e di adattare
i risultati del pre-processing per rispondere correttamente alle interrogazioni sulla matrice modificata

Es.:
1 0 0 0 0 La sottomatrice A[3..4][3…4]
Algorithm 1 Main
è: 1 1
0 1 0 0 0 E il metodo di 2: interrogazione
node null
1
1: function main(Array items, int n)
1
A= 0 0 1 1 0 restituisce True 4:
3: for i 1 to n do
method1(items[i], node)
0 0 1 1 0 5: return method2(node, items, 1)

0 1 0 1 0 La sottomatrice A[3..5][3…4] è: 1 1
Algorithm 1 Main E il metodo di interrogazione
Algorithm 2 Method 1 1
restituisce
1: function main(Array[] items, int n) False
1: function method1(Element e, Node node)
2: if node = null then 0 1
2: node null
3: node.val = e
3: for i 1 to n do
4. Si considerino i seguenti algoritmi4:e: method1(items[i], node) 4:
5:
node.left = null
node.right = null
a. Si descriva il problema che5: si return
intende risolvere
method2(node, n) 6: else
b. Si determini il costo computazionale in termini di tempo di esecuzione
7:
8:
e spazio
if e<node.val then
method1(e, di memoria occupato
node.left())
Algorithm 2 Method 9: else
1: function method1(Element e, Node node)
10: method1(e, node.right())
2: if node = null then
3: node.val = e
Algorithm 1 Main 4: node.left = null Algorithm 3 Another Method
5: node.right = null 1: function method2(Node node, Array items, int i)
1: function main(Array items, int n)
6: else 2: if node = null then
2: node null 7: if e<node.val then 3: return i
3: for i 1 to n do 8: method1(e, node.left()) 4: i method2(node.left, items, i)
4: method1(items[i], node) 9: else 5: items[i] node.val
5: return method2(node, items, 1) 10: method1(e, node.right()) 6: return method2(node.right, items, i+1)

5. DataAlgorithm
la seguente
2 Methodmatrice, che descrive i pesi degli archi di un grafo, calcolare il minimo albero ricoprente con
l’algoritmo
2:
di Kruskal
if node = null then
(mostrare chiaramente il risultato ottenuto dopo ogni iterazione)
1: function method1(Element e, Node node)

3: node.val = e
4:
5:
node.left = null
node.right = null
1 2 3 4 5 6
6: else 1 0 9 2 1 8 10
if e<node.val then
7:
8:
2 9
method1(e, node.left()) 0 6 1 3 8
9: else 3 2 6 0 2 5 1
10: method1(e, node.right())
4 1 1 2 0 3 4
5 8 3 5 3 0 2
Algorithm 3 Another Method
6 10 8
1: function method2(Node node, Array items, int i)
1 4 2 0 1
2: if node = null then
3: return
4: method2(node.left, items, i)
5: items[i] node.val
6: i i+1
7: method2(node.right, items, i)

1
 Compito di Algoritmi e Strutture Dati - B
a.a. 2018/2019 Appello 17/07/2019

1. Risolvere la seguente relazione di ricorrenza:

#
!(#) = 2! ' ) + -√#
16
2. Si consideri una coda con priorità implementata per mezzo di un 3-heap. Supponendo che la coda sia inizialmente
vuota, mostrare l’heap che si ottiene dopo ciascuna delle seguenti istruzioni (commentare opportunamente il modo
in cui si è pervenuti al risultato mostrato):

1. Insert(“B”, 10 ) 6. IncreaseKey(“D”,5)
2. Insert(“C”, 8) 7. Insert(“A”, 3)
3. Insert(“D”, 7) 8. DecreaseKey(“B”,8)
4. Insert(“E”, 9) 9. deleteMin()
5. Insert(“F”, 4) 10. Insert(“G”,4 )

3. Si scriva lo pseudocodice per il metodo isSubString(String s1, String s2). Il metodo deve restituire True se s1 è una
sottostringa di s2 e False altrimenti (Es.: isSubString(“oni”, “Monica”) restituisce True, isSubString(“oni”,
“Manica”) restituisce False). Discuterne la complessità computazionale.
Muniti di questo metodo, progettare un algoritmo isCircular() che, date in input due stringhe s1 e s2, controlli se s2
è una rotazione circolare di s1 usando una sola chiamata di isSubString().
Una stringa s = uv è una rotazione circolare della stringa t se t = vu con v e u sottostringhe di t.

Es.:
s1 = “esame”, s2 = “meesa”, isCircular(s1, s2) restituisce True
s1 = “cucina”, s2 = “acucin”, isCircular(s1, s2) restituisce True
s1 = “monitor”, s2 = “rotimon”, isCircular(s1, s2) restituisce False
s1 = “pera”, s2 = “pesca”, isCircular(s1, s2) restituisce False

4. Si consideri il seguente algoritmo e:

a. Si descriva il problema che intende risolvere
b. Si determini il costo computazionale in termini di numero di confronti nel caso peggiore

Algorithm 1 Method
1: function method(Grafo G=(V,E), nodo v)
2: c 0
3: for 8x 2 V do
4: x.mark False
5: v.mark True
6: for 8x 2 V and x adiacente v do
7: x.mark True
8: for 8x 2 V and x adiacente v do
9: for 8y 2 V and y adiacente x do
10: if y.mark = False then
11: y.mark True
12: c c+1
13: return c

5. Si scriva lo pseudo-codice di un algoritmo iterativo

Algorithm di visita in ampiezza di un grafo a partire da un nodo sorgente
2 Main
s in input al metodo. Simularne il funzionamento (e quindi items,
1: function main(Array mostrare
int n)in che ordine avviene la visita) sul seguente
grafo: 2: node null
3: for i 1 to n do
4: method1(items[i], node)
5: return method2(node, items, 1)
 Compito di Algoritmi e Strutture Dati - A
a.a. 2018/2019 Appello 04/09/2019

1. Risolvere la seguente relazione di ricorrenza:

#
!(#) = 3! ' ( + log #
3
2. Si consideri un albero di ricerca binaria inizialmente vuoto. Mostrare come cambia la struttura dati dopo ciascuna
delle seguenti istruzioni (commentare opportunamente il modo in cui si è pervenuti al risultato mostrato):

1. Insert(“A”, 10 ) 6. Insert(“F”,12)
2. Insert(“B”, 8) 7. Delete(10)
3. Insert(“C”, 7) 8. Delete(9)
4. Insert(“D”, 9) 9. Insert(“G”,10)
5. Insert(“E”, 4) 10. Insert(“H”,11)
11. Delete(“I”,12 )

3. Fornire lo pseudo-codice di una classe e dei relativi metodi per memorizzare un albero con massimo N nodi. Si usi
una variante della tecnica “lista di puntatori ai figli”.
In particolare, si utilizzi un array di N nodi e si tenga traccia del primo elemento disponibile nell’array per
memorizzare un nuovo nodo (attenzione a non superare la capacità massima N). Ogni nodo è caratterizzato da un
Valore, una Chiave e una lista di indici dell’array corrispondenti ai figli del nodo.

Classe Albero{
// pseudo-codice per dichiarare array

nodo trovaNodo(Chiave k); // cerca il nodo la cui chiave è uguale a quella data in input
Lista<Nodo> trovaFigli(Chiave k); // restituisce una lista di nodi che sono figli di un nodo con chiave k
Nodo trovaPadre(Chiave k); // Restituisce il nodo padre del nodo con chiave k
void inserisciNodo(Nodo nodo, Chiave k); //inserisce un nuovo nodo figlio del nodo con chiave k
}

Lo pseudo-codice dev’essere chiaro e accurato. Deve prevedere i controlli necessari per verificare la capacità
dell’array e controllare situazioni quali: chiave inesistente, chiave null, albero vuoto.
Il primo nodo che viene inserito nell’albero (inizialmente vuoto) dev’essere il nodo radice. Quando il metodo
inserisciNodo() riceve in input una chiave null, allora l’utente sta inserendo un nodo radice.

4. Fornire lo pseudo-codice dell’algoritmo di Kruskal

5. Descrivere come implementare una coda con priorità attraverso un d-heap.

 Compito di Algoritmi e Strutture Dati
a.a. 2018/2019 Appello 11/11/2019

1. Senza preoccuparsi del significato, si fornisca lo pseudo-codice di un algoritmo il cui costo computazionale sia
regolato dalla seguente relazione di ricorrenza:
#
!(#) = 3! ' ) + #
2
2. Risolvere la seguente relazione di ricorrenza con la tecnica che si ritiene più opportuna:
#
!(#) = 3! ' ) + #
3

3. Si consideri una tabella hash in cui l’operazione di cancellazione sia supportata e le collisioni siano risolte tramite
la tecnica dell’indirizzamento aperto nota come scansione lineare. Si vogliano memorizzare nella tabella hash un
insieme di parole della lingua Italiana. Come chiave, si usi il primo carattere della parola e si supponga che tale
carattere appartenga all’alfabeto Italiano (non distinguere tra caratteri maiuscoli e minuscoli per semplicità). Come
funzione hash si usi la funzione h(x) = f(x) mod m con m = 10 ed f(x) un numero indicante la posizione del carattere
x nell’alfabeto Italiano (quindi f(‘A’) = 1, f(‘B’) = 2, …f(‘Z’) = 21). Si mostri come varia il contenuto della tabella
hash dopo ciascuna delle seguenti operazioni:

1. Insert(“oro”, “O” ) 6. Insert(“auto”, “A”)

2. Insert(“bue”, “B”) 7. Delete(“C”)
3. Insert(“cuore”, “C”) 8. Insert(“mese”, “M”)
4. Insert(“dado”, “D”) 9. Insert(“napoli”, “N”)
5. Insert(“lavoro”, “L”) 10. Delete(“O” )

4. Si consideri un albero d-ario memorizzato attraverso un vettore posizionale.

a. Fornire lo pseudo-codice di un metodo che permetta la visita in ampiezza dell’albero scandendo
opportunamente l’array;
b. Fornire lo pseudo-codice di un metodo che permetta la visita in profondità in pre-ordine dell’albero
scandendo opportunamente l’array.

5. Si dimostri il costo computazione dell’algoritmo del QuickSort randomizzato nel caso medio.
 Compito di Algoritmi e Strutture Dati
a.a. 2018/2019 Appello 15/01/2020

1. Senza preoccuparsi del significato, si fornisca lo pseudo-codice di un algoritmo il cui costo computazionale sia
regolato dalla seguente relazione di ricorrenza:
#
!(#) = 2! ' ) + #+
3
2. Risolvere la seguente relazione di ricorrenza con la tecnica che si ritiene più opportuna:
#
!(#) = 2! ' ) + √2#
4
3. Dato il seguente grafo,

Si fornisca la sua rappresentazione in termini di:

a. lista di archi;
b. liste di adiacenza;
c. liste di incidenza;
d. matrice di adiacenza;
e. matrice di incidenza.

Per ciascuna delle suddette rappresentazioni, si discutano i tempi di esecuzione delle operazioni di aggiunta di un
arco o di un vertice, rimozione di un arco o di un vertice, calcolo degli archi incidenti un vertice, controllo
dell’adiacenza di due vertici.

4. Usando la rappresentazione vettore padri per gli alberi, fornire lo pseudo codice dei metodi makeset(elem e),
union(set a, set b) e find(elem e) per una struttura dati di tipo QuickFind. Si assuma che la struttura dati debba
memorizzare elementi univoci di tipo intero compresi tra 1 ed N dove N è anche il numero massimo di elementi
memorizzabili nella QuickFind. Si implementi la struttura dati attraverso un unico array di N elementi
(suggerimento: si usi ciascun elemento come indice dell’array). Successivamente, si illustrino le modifiche
all’implementazione fornita in modo da operare un bilanciamento della union.

5. Si dimostri il costo computazione dell’algoritmo del QuickSort randomizzato nel caso medio.
 Compito di Algoritmi e Strutture Dati
a.a. 2018/2019 Appello 04/02/2020

1. Senza preoccuparsi del significato, si fornisca lo pseudo-codice di un algoritmo il cui costo computazionale sia
regolato dalla seguente relazione di ricorrenza:

# # #+
!(#) = 2! ' ) + ! ' ) +
3 2 2

2. Risolvere la seguente relazione di ricorrenza con la tecnica che si ritiene più opportuna:
#
!(#) = 2! ' ) + #+
2
3. Si consideri un albero AVL per la memorizzazione di oggetti con chiave intera inizialmente vuoto. Mostrare
l’albero che si ottiene dopo ciascuno delle seguenti operazioni (commentare opportunamente il modo in cui si è
pervenuti al risultato mostrato):
a. Inserisci(18)
b. Inserisci(12)
c. Inserisci(15)
d. Inserisci(14)
e. Inserisci(13)
f. cancella(14)

4. Si supponga di dover memorizzare, in una struttura dati, oggetti di una classe per i quali è disponibile il metodo
hashcode() che restituisce il codice hash dell’oggetto chiamante.
Si progetti una classe che implementi una tabella hash in cui le collisioni sono gestite per mezzo di liste. La classe
deve prevedere i metodi: put(Key k, Value v), get(Key k), remove(Key k). Fornire lo pseudo-codice dettagliato
di ciascuno dei metodi evidenziando le operazioni sulle strutture dati necessarie alla classe per implementare la
tabella hash.

5. Si dimostri che “Un heap con n nodi ha altezza Θ(log n)”

 Compito di Algoritmi e Strutture Dati – Primo turno
a.a. 2019/2020
Appello 08/06/2020

1. Si risolva la seguente relazione di ricorrenza con il metodo dell’iterazione:

', #=1
!(#) = & #
! * , + log # , #>1
2

2. Dato il seguente albero:

a. Verificare che sia un heap binomiale;

b. Mostrare l’effetto che hanno sulla struttura dati le seguenti operazioni (commentare opportunamente il
modo in cui si è pervenuti al risultato mostrato):
i. Insert(2)
ii. Insert(4)
iii. DeleteMin()
iv. Delete(10)
v. DeleteMin()

c. Infine si applichi l’operazione Merge() tra l’heap ottenuto al passo precedente e il seguente heap:

3. Fornire lo pseudo-codice dettagliato di una classe che implementi una tabella Hash con liste di collisione per mezzo
di un array di dimensione m. Si prevedano i metodi tipici di un dizionario: inserisci, cancella, ricerca. Si supponga
che l’utente voglia inserire oggetti muniti di un metodo hashcode() da utilizzarsi per memorizzare l’elemento
usando il metodo della divisione.

4. Fornire lo pseudo-codice dell’algoritmo di ordinamento insertionSort e dimostrarne il costo computazionale.

5. Si consideri il grafo in figura e si mostrino le varie rappresentazioni in memoria che è possibile ottenere con le
tecniche note. Infine, descrivere i costi computazionali delle varie tecniche per le operazioni di: inserimento di un
arco, inserimento di un nodo, verifica dell’adiacenza di due nodi, ricerca degli archi incidenti un dato nodo.
 Compito di Algoritmi e Strutture Dati – Primo turno
a.a. 2019/2020
Appello 25/06/2020

1. Si risolva la seguente relazione di ricorrenza:

', #=1
!(#) = & #
4! + - + #/ , #>1
2

2. Date le stringhe STELLA e SELLATA, calcolare la distanza tra le due stringhe utilizzando la edit distance
(programmazione dinamica). Evidenziare la sequenza di operazioni necessarie per trasformare Stella in Sellata.

3. Fornire lo pseudo-codice dettagliato di una classe che implementi una coda con priorità attraverso un d-heap in cui
il parametro d è passato in input dall’utente della classe attraverso il costruttore. Si implementi il d-heap attraverso
un array di oggetti che memorizzino all’interno un elemento ed una chiave (la priorità). Su usi come notazione la
rappresentazione vettore posizionale. Prevedere nella classe i metodi findMin(), insert(elem, chiave), deleteMin().
La descrizione di questi metodi deve mettere in risalto le operazioni fatte sul vettore posizionale per gestire la coda
con priorità.

4. Fornire lo pseudo-codice dell’algoritmo di ordinamento MergeSort e dimostrarne il costo computazionale.

5. Considerando una struttura dati di tipo QuickFind inizialmente vuota, si mostri come varia tale struttura dopo le
seguenti operazioni e il loro eventuale output
a. makeSet(2), makeSet (4), makeSet (6)
b. union(6, 4)
c. makeSet (1), makeSet (5)
d. union(5, 2), union(6, 1)
e. find(4), find(1), find(2)
f. makeset(3), union(3, 6)
 Compito di Algoritmi e Strutture Dati – Primo turno
a.a. 2019/2020
Appello 08/07/2020

1. Si consideri la seguente relazione di ricorrenza:

', #=1
!(#) = & # #
! * , + ! * , + #, #>1
2 4
Si dimostri, con il metodo della sostituzione, che T(n) = O(n)

2. Dato il seguente albero AVL, mostrare come cambia la struttura dati dopo ciascuna delle seguenti operazioni
(commentate opportunamente).
a. Inserisci(10)
b. Inserisci (5) 50
c. Inserisci(100)
d. Inserisci(175)
e. Inserisci(180)
f. Cancella(25) 25

3. Si consideri una sequenza di interi positivi X. La cancellazione da X di un certo numero di elementi determina una
sottosequenza. La sottosequenza è crescente se il valore dei suoi elementi è crescente. La lunghezza della
sottosequenza è il numero di elementi che la compongono. Data la sequenza X = (x1, x2, . . . xn) a valori distinti si
consideri il problema di trovare la sottosequenza crescente di X di lunghezza massima.
Ad esempio, per X = (40, 2, 101, 47, 3, 34, 30) la prima sottosequenza crescente di lunghezza massima è (2, 3, 34).
Progettare un algoritmo basato su programmazione dinamica che risolva il problema. Dimostrarne il costo
computazionale.

4. Fornire lo pseudo-codice dell’algoritmo BucketSort e dimostrarne il costo computazionale.

5. Si enunci e si dimostri il teorema relativo al numero massimo di alberi binomiali presenti in un heap binomiale che
memorizza n elementi.
 Compito di Algoritmi e Strutture Dati
a.a. 2019/2020
Appello 09/09/2020

1. Si supponga di dover scegliere tra due soluzioni software A e B il cui costo computazionale è regolato dalle seguenti
relazioni di ricorrenza:
(
Soluzione A: !(#) = 3! ' ) * + log #

(
Soluzione B: !(#) = 2! '0 * + #

Dopo aver risolto le relazioni di ricorrenza, indicare quale delle due soluzioni è computazionalmente più
conveniente utilizzare.

2. Si consideri una coda con priorità implementata per mezzo di un 3-heap. Supponendo che la coda sia inizialmente
vuota, mostrare l’heap che si ottiene dopo ciascuna delle seguenti istruzioni (commentare opportunamente il modo
in cui si è pervenuti al risultato mostrato):

1. Insert(“A”, 10 ) 9. deleteMin()
2. Insert(“B”, 8) 10. Insert(“G”,4 )
3. Insert(“C”, 7) 11. Delete(“D”)
4. Insert(“D”, 9) 12. IncreaseKey(“C”,4)
5. Insert(“E”, 4) 13. Insert(“H”, 13)
6. IncreaseKey(“C”,4) 14. DecreaseKey(“A”,8)
7. Insert(“F”, 3) 15. deleteMin()
8. DecreaseKey(“A”,8) 16. Insert(“I”,4 )
17. Delete(“H”)

3. Dato un array A[1..n] contenente, in un ordine qualsiasi, numeri interi tra 1 ed n.

Progettare un algoritmo con costo computazionale O(n) che permetta di verificare, senza l’ausilio di ulteriori
strutture dati, se all’interno dell’array un elemento è ripetuto più di una volta.

ES.:
A = [ 2 4 5 4 1], l’elemento ripetuto è il 4
A = [ 1 3 3 3 4 6], l’elemento ripetuto è il 3
A = [ 3 4 2 1], non vi sono elementi ripetuti

4. Fornire lo pseudo-codice dell’algoritmo QuickSort randomizzato e dimostrarne il costo computazionale nel caso
medio.

5. Dimostrare che, in un albero di Fibonacci di altezza h con n nodi, l’altezza è ℎ = Θ(log #)

 Compito Algoritmi e Strutture Dati
24 Gennaio 2022 – Gruppo 2

1. Risolvere la seguente equazione di ricorrenza

T(n) = 4T(⌊n/4⌋) + Θ(n2)

2. Simulare l’algoritmo del bubbleSort sul seguente array s = [5, 2, 6, 8, 4, 2, 10]. Mostrare come
cambia l’array dopo ogni iterazione.

3. Determinare il costo computazionale del seguente algoritmo in funzione del numero di

moltiplicazioni e divisioni (trascurare le altre operazioni).
Se necessario, ricordare che

4. Utilizzando l’edit distance, determinare la distanza tra le stringhe PEZZA e PREZZO e la

sequenza ottima di operazioni necessarie per trasformare la prima stringa nella seconda

5. Scrivere un algoritmo ricorsivo in modo tale che il suo tempo di esecuzioni soddisfi la relazione
#(%) = 2#(% − 1) + log (%)

6. Dimostrare che un albero AVL con n nodi ha altezza O(log n)

7. Si consideri un albero AVL inizialmente vuoto. Ricordando che le signature dei metodi sono del tipo
insert(Value, Key), delete(Key), mostrare come cambia la struttura dell’albero dopo ciascuna delle seguenti
operazioni. Commentare opportunamente in modo che sia chiaro il perché dei cambiamenti alla struttura
dati.

1. Insert(“A”,10 ) 5. Insert(“E”, 2)
2. Insert(“B”, 4) 6. Insert(“F”, 1)
3. Insert(“C”, 3) 7. Insert(“G”,9)
4. Insert(“D”, 8) 8. Delete(4)

8. Dato il grafo in figura, determinare attraverso l’algoritmo di Kruskal, il minimum spanning tree.
Attraverso opportuni commenti spiegare quali sono gli step seguiti per la sua determinazione e
specificare il costo dell’albero individuato.
9. Sia dato un albero binario di ricerca T e due elementi A e B. Progettare un algoritmo che, nel caso in cui A
e B siano entrambi contenuti in T, restituisca il più profondo degli antenati comuni ad A e B (o uno dei due
nodi se questi è antenato dell’altro), altrimenti restituisca un opportuno messaggio di errore. Discutere il
costo computazionale dell’algoritmo proposto. Commentare opportunamente l’uso di eventuali strutture dati
ausiliarie.s
Es.:
1) A = 123, B = 98. Antenato comune: 100
2) A = 123, B = 111. Restituisce 111
3) A = 10, B = 34. Restituisce messaggio di errore
 Compito Algoritmi e Strutture Dati
7 Febbraio 2022 – Gruppo 1

1. Calcolare un upper-bound per la seguente relazione di ricorrenza:

T(n) = T(n-1) + n

2. Simulare l’algoritmo del selectionSort sul seguente array s = [5, 2, 6, 8, 4, 2, 10]. Mostrare come
cambia l’array dopo ogni iterazione.

3. Determinare il costo computazionale del seguente algoritmo sapendo che la valutazione della
funzione f() ha un costo computazionale O(n). Discutere il costo dell’algoritmo in funzione dei
valori che possono assumere n ed m (per es.: per n>>m o per m>>n).

4. Utilizzando l’edit distance, determinare la distanza tra le stringhe RESTO e DENTE e la sequenza
ottima di operazioni necessarie per trasformare la prima stringa nella seconda

5. Scrivere un algoritmo ricorsivo in modo tale che il suo tempo di esecuzioni soddisfi la relazione
$(&) = 2$(& − 1) + $(&/2) + &log (&)

6. Si dimostri che un albero binario T con k foglie ed in cui ogni nodo interno ha esattamente 2 figli
ha altezza pari ad almeno log1 2.

7. Si consideri una coda con priorità implementata attraverso un 3-heap. Sia la coda inizialmente vuota.
Ricordando che le signature dei metodi sono del tipo insert(Value, Key), deleteMin(), mostrare come cambia
la struttura della coda dopo ciascuna delle seguenti operazioni. Commentare opportunamente in modo che
sia chiaro il perché dei cambiamenti alla struttura dati.

1. Insert(“A”,10 ) 5. Insert(“E”, 2)
2. Insert(“B”, 4) 6. Insert(“G”,9)
3. Insert(“C”, 3) 7. DeleteMin()
4. Insert(“D”, 8) 8. Insert(“F”, 1)

8. Dato il grafo in figura, determinare attraverso l’algoritmo di Prim e partendo dal nodo T, il
minimum spanning tree. Attraverso opportuni commenti spiegare quali sono gli step seguiti per la
sua determinazione e specificare il costo dell’albero individuato.
9. Si supponga di avere un sistema che memorizzi, in un array A, n elementi interi in un range [0, k]. Si è
interessati ad interrogare il sistema attraverso delle query in modo da sapere quanti elementi nell'array A
sono strettamente maggiori di un valore x in input da tastiera.
Progettare un algoritmo che sia in grado di rispondere a ciascuna query in tempo O(1) sfruttando eventuali
strutture dati ausiliare ed un algoritmo di pre-processing (che dovete progettare) formulato ad-hoc.

Es. A = [3, 8, 9, 1, 5 , 5, 6 , 7, 6]

query(3.5) --> restituisce 7

query(7) --> restituisce 2
query(10.5) --> restituisce 0
query(0) --> restituisce 9
 Compito Algoritmi e Strutture Dati
21 Febbraio 2022 – Gruppo 1

1. Calcolare un upper-bound per la seguente relazione di ricorrenza:

T(n) = T(n-1) + n2

2. Simulare l’algoritmo merge sul seguente array s = [2, 4, 6, 8, 1, 3, 5, 10] considerando la chiamata
merge(s, 1, 4, 8). Si supponga che vi sia solo una chiamata a merge (non dovete simulare l’intero
MergeSort ma solo la funzione ausiliaria merge(Array A, int i1, int f1, int f2)). Mostrare cosa succede
ad ogni iterazione.

3. Supponendo che il seguente algoritmo riceva in input un array bidimensionale di dimensione n x n,

si determini la complessità computazionale (nel tempo). Mostrare i passaggi matematici che
conducono al risultato.

4. Utilizzando l’edit distance, determinare la distanza tra le stringhe PROVA e PIOVRA e la

sequenza ottima di operazioni necessarie per trasformare la prima stringa nella seconda

5. Data la seguente matrice dei pesi per un grafo orientato di 6 nodi, calcolare e tracciare l’albero dei
cammini minimi a partire dal nodo s.
DA\A s a b c d e
s 0 4 3 - - 10
a - 0 - 6 4 -
b - 1 0 5 - 2
c - - - 0 3 2
d - 3 - - 0 -
e - - 7 1 2 0

6. Spiegare in modo formale la differenza tra albero dei cammini minimi e minimo albero ricoprente.

7. Si consideri l’albero AVL in figura. Mostrare come varia la struttura dati dopo ciascuna delle seguenti
operazioni.
 1. Insert(“A”,72 ) 4. Insert(“D”, 68)
2. Insert(“B”, 71) 5. Delete(96)
3. Insert(“C”, 50)

8. Si consideri un grafo non orientato G con n nodi, rappresentato in memoria attraverso una matrice
di adiacenza M.
Si progetti l’algoritmo isCycle che, data in input la matrice M ed una sequenza ordinata di nodi
senza ripetizioni, verifichi se la sequenza di nodi costituisce un ciclo o meno. L’algoritmo restituisce
un valore booleano o lancia una eccezione se qualche nodo nella sequenza non è memorizzato nel
Grafo G.

ES.

G=

isCycle(G, {s, A, D, B}) à True

isCycle(G, {D, E, C, B}) à True
isCycle(G, {s, A, C, B}) à False
isCycle(G, {C, E, F}) à False
isCycle(G, {A, D, E, G, F}) à False
isCycle(G, {A, D, B, K}) à Lancia eccezione
 Compito Algoritmi e Strutture Dati - 11 Aprile 2022 – GRUPPO 2

1. Si consideri l’algoritmo in Figura. Simulare l’esecuzione dell’algoritmo supponendo che A= [4,2,1,2,2,1,4,2], k =

4 e B sia un array di opportune dimensioni inizializzato a valori nulli. Mostrare come varia il contenuto dell’array
C e dell’array B durante l’esecuzione dell’algoritmo.

2. Determinare il costo computazionale dell’algoritmo dell’esercizio 1 sapendo che A è un array di n elementi che
variano nel range [1, k]. Discutere il costo dell’algoritmo in funzione dei valori che possono assumere n e k (per
es.: per n>>k o per k>>n).

3. Calcolare un upper-bound per la seguente relazione di ricorrenza:

T(n) = T(n-2) + n/2

4. Si consideri una coda con priorità implementata attraverso un 2-heap. Sia la coda inizialmente vuota. Ricordando
che le signature dei metodi sono del tipo insert(Value, Key), deleteMin(), mostrare come cambia la struttura della
coda dopo ciascuna delle seguenti operazioni. Commentare opportunamente in modo che sia chiaro il perché dei
cambiamenti alla struttura dati.

1. Insert(“A”,10 ) 5. Insert(“E”, 2)
2. Insert(“B”, 4) 6. Insert(“G”,9)
3. Insert(“C”, 3) 7. DeleteMin()
4. Insert(“D”, 8) 8. Insert(“F”, 1)

5. Si dimostri il seguente lemma relativo al BubbleSort: dopo l’i-esima iterazione, gli elementi A[n-i+1]… A[n] sono
correttamente ordinati e occupano la corretta posizione, ovvero

6. Dato il grafo in figura determinare. attraverso l’algoritmo di Prim e partendo dal nodo e, il minimum spanning
tree. Attraverso opportuni commenti spiegare quali sono gli step seguiti per la sua determinazione e specificare il
costo dell’albero individuato.

7. Si progetti un algoritmo che, data in input una sequenza di caratteri indicizzati con indice i da 1 ad n, individui
quale di essi è necessario eliminare per ottenere un palindromo. L’algoritmo restituisce l’indice del carattere da
eliminare. Segnala un errore se non è possibile ottenere un palindromo. Un palindromo è una sequenza
di caratteri che, letta al contrario, rimane invariata. Si presenti il costo computazionale dell’algoritmo proposto.

Es.
MAMMA à eliminando la prima M si ottiene AMMA, un palindromo, restituisce 1
ERTE à eliminando la R si ottiene ETE, un palindromo, restituisce 2
ETTO à eliminando una sola lettera non è possibile ottenere un palindromo, segnala errore
ADRARDAà eliminando la A centrale, si ottiene ADRRDA che è un palindromo, restituisce 4
 Compito di ASD – Gruppo 2
6/6/2022 – tempo 1h e 30’

1. Dimostrare attraverso il metodo di sostituzione (induzione) che il lower-bound del costo computazionale di un algoritmo
ricorsivo regolato dalla seguente relazione di ricorrenza è Omega(n log n). [Altri metodi di risoluzione non saranno valutati!]
#
2! ) * + # # > 2
!(#) = ' 2
- # ≤ 2, - > 0

2. Calcolare il costo computazionale nel caso peggiore dell’algoritmo in figura supponendo che le valutazioni di f(x) e di f’(x)
abbiano entrambe costo O(z)

3. Dimostrare che “In un heap binomiale con n nodi, vi sono al più ⌊2345 #⌋ + 1 alberi binomiali, ciascuno con grado ed altezza
O(log n)”

4. Calcolare (e tracciare graficamente), con un opportuno algoritmo (e giustificando la scelta), l’albero dei cammini minimi a partire
dal nodo A di un grafo caratterizzato dalla seguente matrice dei pesi:

da\a A B C D E
A - 4 2 inf inf
B 4 - 8 6 2
C 2 8 - 3 inf
D inf 6 3 - 8
E inf 2 inf 8 -

5. Si supponga di utilizzare un QuickUnion inizialmente vuoto. Si facciano 7 makeset(i) con i = 1...7. Utilizzando l’euristica di
path-splitting nell’operazione di find, mostrare come varia la struttura dati dopo ciascuna delle seguenti operazioni:
1. union(2,3) 5. union(5,4)
2. union(5,6) 6. union(2,5)
3. union(5,7) 7. find(7)
4. union(2,1)

6. La struttura di un albero binario di ricerca dipende dall’ordine con il quale si inseriscono gli elementi. Si progetti un algoritmo
che, dati in input due alberi binari di ricerca T1 e T2 restituisca True se i 2 alberi contengono esattamente gli stessi elementi e
False altrimenti. Si supponga che gli alberi siano implementati con la rappresentazione puntatori ai figli e ogni albero memorizzi
il numero di nodi in esso presenti in un attributo opportuno. Si richiede il dettaglio di eventuali funzioni ausiliarie usate nello
pseudo-codice e il commento al costo computazionale. Es.:
Albero A Albero B Albero C

sonoUguali(A,B)àTrue
sonoUguali(A,C)àFalse
sonoUguali(C,B)àFalse
 Compito di ASD – Gruppo 2
21/6/2022 – tempo 1h e 30’

1. Dimostrare attraverso il metodo di sostituzione (induzione) che il lower-bound del costo computazionale
di un algoritmo ricorsivo regolato dalla seguente relazione di ricorrenza è Omega(n). [Altri metodi di
risoluzione non saranno valutati!]
#
!( *+# # > 2
!(#) = ' 2
-.#/0 # ≤ 2, -.#/0 > 0

2. Calcolare il costo computazionale nel caso peggiore dell’algoritmo in figura

3. Dimostrare il seguente Teorema: “Sia T un albero binario in cui ogni nodo interno ha esattamente 2 figli
e sia k il numero delle sue foglie. L’altezza di T è almeno 4.56 7”.

4. Calcolare (e tracciare graficamente), con un opportuno algoritmo (e giustificando la scelta), l’albero dei
cammini minimi a partire dal nodo A di un grafo caratterizzato dalla seguente matrice dei pesi:
da\a A B C D E
A - 14 12 inf inf
B 4 - 18 16 12
C 12 18 - 13 inf
D inf 16 13 - 18
E inf 12 inf 18 -

5. Si supponga di utilizzare un QuickUnion inizialmente vuoto. Si facciano 7 makeset(i) con i = 1...7.

Utilizzando l’euristica di path-halving nell’operazione di find, mostrare come varia la struttura dati dopo
ciascuna delle seguenti operazioni:
5. union(2,3) 5. union(1,5)
6. union(7, 4) 6. union(2,1)
7. union(5,6) 7. find(4)
8. union(5,7)
6. Si supponga di avere un grafo in cui i nodi rappresentano città e gli archi collegamenti tra le città.
Supponendo che il grafo sia memorizzato attraverso liste di adiacenza, si fornisca lo pseudocodice di un
algoritmo che, data in input una città, enumeri tutte le città non adiacenti a quella iniziale e che è possibile
raggiungere attraversando una città intermedia. (ATTENZIONE: L’uso di strutture dati diverse da quella
indicata per la memorizzazione del grafo renderà nulla la valutazione dell’esercizio)

Es.:
da Roma raggiungo Anagni, Albano, Ostia
da Tivoli raggiungo Albano,
Ostia, Fiumicino, Frascati
 Compito di ASD
12/09/2022 – tempo 1h e 30’
1. Risolvere la seguente relazione di ricorrenza:
#
!(#) = ! ' ) + #+
4
2. Calcolare il costo computazionale nel caso peggiore dell’algoritmo in figura. (Attenzione: il secondo ciclo
decrementa j)

3. Dimostrare il seguente Teorema: “Sia T un albero binario in cui ogni nodo interno ha esattamente 2 figli
e sia k il numero delle sue foglie. L’altezza di T è almeno ,-.+ /”.

4. Data la tabella hash ad indirizzamento aperto con scansione quadratica (si assuma h(k) = (k + i2) mod m),
si mostri come viene modificata la tabella dopo ogni operazione:

1. insert(10)
4. insert(15)
2. insert(39)
5. insert(14)
3. insert(68)

5. Si consideri la seguente coda con priorità rappresentata attraverso un heap binomiale. Mostrare come varia
la coda dopo le seguenti operazioni

1. deleteMin() 5. deleteMin()
2. deleteMin() 6. insert(1)
3. deleteMin()
4. deleteMin()

6. Si progetti un algoritmo di costo O(n log n) che, date in input due stringhe (due array di caratteri) e le loro
rispettive dimensioni, produca in uscita True se le due stringhe sono una l’anagramma dell’altra e False
altrimenti. Data una stringa, un anagramma è una stringa della stessa lunghezza della stringa data ed è
ottenuta tramite permutazione delle lettere.
Es. :
isAnagramma(“ingolfare”, 9, “fragoline”, 9) à True
isAnagramma(“ciarle”, 6, “larice”, 6) à True
isAnagramma(“botola”, 6, “rotola”, 6) à False
isAnagramma(“ingolfare”, 9, “volare”, 6) à False
 Compito di ASD – Gruppo 1
05/07/2022 – tempo 1h e 30’

1. Risolvere la seguente relazione di ricorrenza:

#
!(#) = 2! ( * + #,
4
2. Calcolare il costo computazionale nel caso peggiore dell’algoritmo in figura sapendo che il costo della
funzione do_something() è O(1)

3. Dimostrare il seguente Teorema: “Sia T un albero binario in cui ogni nodo interno ha esattamente 2 figli
e sia k il numero delle sue foglie. L’altezza di T è almeno -./, 0”.

4. Data la tabella hash ad indirizzamento aperto con scansione lineare, si mostri come viene modificata la
tabella dopo ogni operazione:

1. insert(92) 5. insert(39)
2. delete(84) 6. delete(5)
3. insert(114)

5. Si consideri una coda con priorità inizialmente vuota e rappresentata attraverso un heap binomiale.
Mostrare come varia la coda dopo le seguenti operazioni
1. insert(24) 5. insert(12)
2. insert(1) 6. insert(11)
3. insert(3) 7. insert(2)
4. insert(14) 8. insert(25)
6. Dati in input un array A di n numeri interi e positivi ed un valore intero positivo K, si progetti un algoritmo
di costo massimo O(n log n) che stampi, se esistono, tutte le coppie all’interno dell’array A la cui somma
è pari al valore K. Dimostrare quindi il costo computazionale dell’algoritmo proposto.

Es.
A = [8, 7, 2, 1, 10, 1, 3, 4, 5, 9]
K = 10 à (8, 2), (7, 3), (1, 9)

K = 15 à (8, 7), (10, 5)

K = 20 ànessuna coppia
K=2 à (1, 1)
 Compito di ASD – GRUPPO 1
23/01/2023 – tempo 1h e 30’

1. Risolvere la seguente relazione di ricorrenza: !(#) = 8!(#/2) + #4

2. Analizzare, nel caso peggiore, il costo computazionale nel

tempo dell’algoritmo in figura. Porre attenzione al modo in cui
sono incrementate le variabili di ciclo!

3. Sia T un albero delle decisioni e, quindi, un albero binario in cui ogni nodo interno ha esattamente 2 figli;
sia k il numero delle sue foglie. Dimostrare che l’altezza di T è almeno log2 +

4. Dato un grafo caratterizzato dalla seguente matrice dei

pesi degli archi, determinare e tracciare l’albero dei
cammini minimi con un opportuno algoritmo a partire
dal nodo B

5. Data la seguente coda con priorità implementata attraverso heap, mostrare come varia la coda dopo
ciascuna delle operazioni di seguito indicate.

a. deleteMin()
b. deleteMin()
c. Insert(8)
d. Insert(39)
e. deleteMin()
f. deleteMin()
g.

6. Sia dato un albero binario rappresentato attraverso vettore posizionale e i cui nodi memorizzino valori
interi. Si stampi, per ogni nodo foglia f, il numero di nodi lungo il cammino dalla radice r alla foglia f che
memorizzano un valore pari. La soluzione proposta deve esplicitare in che modo usare il vettore posizionale
per risolvere il problema.

Stampa:
114à 2
16à 2
27 à 2
12à 3
20à 1
26à1
 Compito di ASD – GRUPPO 1
20/02/2023 – tempo 1h e 30’

!
1. Risolvere la seguente relazione di ricorrenza con il metodo dell’iterazione: !(#) = ! '" ( + log #
(Attenzione, l’uso di altre tecniche sarà valutato come errore)

2. Analizzare, nel caso peggiore, il costo computazionale nel

tempo dell’algoritmo in figura. Porre attenzione al modo in
cui sono modificate le variabili!

3. Dimostrare che un d-heap con n nodi ha altezza -(log # #)

4. Dato il seguente vettore V, determinare ed individuare il sotto-vettore di somma massima. Mostrare tutti i
passi necessari per la simulazione dell’algoritmo utilizzato.
V = [3, 4, -8, 4, 2, -5, 10, -2, 8, 1, -3]

5. Dato il seguente albero AVL, mostrare come cambia la struttura dati dopo ciascuna delle operazioni di
seguito indicate.

a. Insert(27)
b. Insert(33)
c. delete(36)
d. delete(54)
e. delete(35)
f. insert(10)

6. Si forniscano due versioni dell’algoritmo GRADO(nodo v) che, dato un nodo di un albero T, restituisca il
grado del nodo. La prima versione assuma che l’albero sia rappresentato tramite la struttura dati primo
figlio – fratello successivo. La seconda versione assuma che l’albero sia rappresentato attraverso la
struttura dati vettore dei padri. Commentare e confrontare opportunamente i costi computazionali delle
due versioni.
r

v GRADO(r) restituisce 2
GRADO(v) restituisce 3
s GRADO(s) restituisce 0
 Compito di ASD – GRUPPO 2
20/02/2023 – tempo 1h e 30’

!
1. Risolvere la seguente relazione di ricorrenza con il metodo dell’iterazione: !(#) = ! '" ( + log #
(Attenzione, l’uso di altre tecniche sarà valutato come errore)

2. Analizzare, nel caso peggiore, il costo computazionale nel

tempo dell’algoritmo in figura. Porre attenzione al modo in cui
sono modificate le variabili!

3. Dimostrare che un d-heap con n nodi ha altezza -(log # #)

4. Dato il seguente vettore V, determinare ed individuare il sotto-vettore di somma massima. Mostrare tutti i
passi necessari per la simulazione dell’algoritmo utilizzato.
V = [4, 5, -10, 5, 3, -7, 11, -3, 9, 2, -2]

5. Dato il seguente albero AVL, mostrare come cambia la struttura dati dopo ciascuna delle operazioni di
seguito indicate.

1. Insert(38)
2. Insert(44)
3. delete(47)
4. delete(65)
5. delete(46)
6. insert(21)

6. Si forniscano due versioni dell’algoritmo SOMMA(nodo v) che, dato un nodo di un albero T, restituisca la
somma dei valori memorizzati nei nodi figli. La prima versione dell’algoritmo assuma che l’albero sia
rappresentato tramite la struttura dati primo figlio – fratello successivo. La seconda versione assuma che
l’albero sia rappresentato attraverso la struttura dati vettore dei padri. Commentare e confrontare
opportunamente i costi computazionali delle due versioni.
r

v SOMMA(r) restituisce 54
SOMMA(v) restituisce 3
s SOMMA(s) restituisce 119
 Compito di ASD – GRUPPO 1
13/04/2023 – tempo 1h e 30’

!
1. Risolvere la seguente relazione di ricorrenza: !(#) = 2! (" ) + #

2. Analizzare, nel caso peggiore, il costo computazionale nel

tempo dell’algoritmo in figura.

3. Dimostrare che un d-heap con n nodi ha altezza +(log # #)

4. Data la seguente tabella hash ad indirizzamento aperto con scansione quadratica caratterizzata dalla
funzione h(k) = (k + i2) mod m, si mostri come viene modificata la tabella dopo ogni operazione:

a) Insert(29)
b) Insert(48)
c) Insert(86)
d) Insert(52)

5. Date le stringhe LAUREARE e LAVORARE, calcolare la distanza tra le due stringhe utilizzando la edit
distance. Evidenziare la sequenza di operazioni necessarie per trasformare LAUREARE in LAVORARE.

6. Si progetti un algoritmo con costo computazionale O(n) che, dato in input un array A di n numeri interi,
restituisca gli indici (iniziale e finale) del sotto-array che è necessario ordinare affinché l’intero array in
input risulti ordinato in modo crescente. (Il problema ammette più di una soluzione. Si commenti
opportunamente la soluzione presentata)

Es: (supponendo che gli indici partano da 1)

A = [10, 20, 30, 70, 50, 60, 40, 80] à iniziale = 4, finale = 7
A = [10, 20, 70, 35, 50, 60, 40, 54] à iniziale = 3, finale = 8
A = [22, 20, 30, 21, 50, 60, 70, 80] à iniziale = 1, finale = 4
A = [22, 20, 30, 70, 50, 60, 40, 45] à iniziale = 1, finale = 8
 Compito di ASD – GRUPPO 1
06/02/2023 – tempo 1h e 30’

1. Risolvere la seguente relazione di ricorrenza con il metodo dell’iterazione: !(#) = !(# − 1) + # − 1

2. Analizzare, nel caso peggiore, il costo computazionale nel

tempo dell’algoritmo in figura. Porre attenzione al modo
in cui sono modificate le variabili!

3. Sia T un albero di Fibonacci di altezza h e sia nh il numero dei suoi nodi. Dimostrare che ℎ = Θ(log #! )

4. Calcolare la distanza minima (edit distance) tra le stringhe ALBERO e LABBRO. Ricostruire la sequenza
di operazioni necessarie per allineare le due stringhe.

5. Data la seguente coda con priorità implementata attraverso heap binomiale, mostrare come varia la coda
dopo ciascuna delle operazioni di seguito indicate.

a. deleteMin()
b. deleteMin()
c. Insert(8)
d. Insert(1)
e. deleteMin()
f. deleteMin()

6. Si progetti un algoritmo BINARIO(Tree T) che, dato un albero T rappresentato tramite la struttura dati
primo figlio – fratello successivo, restituisca TRUE se l’albero è in realtà un albero strettamente binario
(ogni nodo che non è una foglia ha esattamente grado 2) e FALSE altrimenti.

FALSE FALSE TRUE FALSE

(77 ha grado 1) (22 ha grado 3) (37 ha grado 1)
 Compito di ASD
12/06/2023 – tempo 1h e 30’
!
1. Risolvere la seguente relazione di ricorrenza !(#) = 2! '" ( + #
Quindi, si scriva lo pseudo-codice di un algoritmo iterativo il cui costo computazionale nel caso
peggiore sia uguale a quello appena calcolato.

2. Analizzare e dimostrare formalmente il costo

computazionale (tempo) nel caso peggiore
dell’algoritmo in figura.

3. Dimostrare il seguente Teorema:

Sia T un albero binario in cui ogni nodo interno ha esattamente 2 figli e sia k il numero delle sue
foglie. L’altezza di T è almeno *+,# -

4. Data la coda con priorità in figura, mostrare come varia

la struttura dati dopo ciascuna delle seguenti operazioni

1. Delete(39)
2. DeleteMin()
3. Insert(10)
4. Delete(123)

5. Determinare l’albero dei cammini minimi a partire dal nodo A per A B C D E F

un grafo caratterizzato dalla matrice dei pesi a fianco. A - 3 5 9 - -
B 3 - 3 4 7 -
C 5 3 - 2 6 8
6. Progettare un algoritmo che, dato un generico albero binario D 9 4 2 - 2 2
memorizzato attraverso puntatori ai figli, determini la distanza E - 7 6 2 - 5
minima tra la radice e le foglie dell’albero. La distanza tra due nodi
F - - 8 2 5 -
è il numero di nodi da attraversare per spostarsi da un nodo sorgente
ad uno di destinazione.

Distanza minima è 2 (tra nodo 50 e nodo 10)

 Compito di ASD
26/06/2023 – tempo 1h e 30’
!
1. Risolvere la seguente relazione di ricorrenza !(#) = 3! '" ( + ##
Quindi, si scriva lo pseudo-codice di un algoritmo iterativo il cui costo computazionale nel caso
peggiore sia uguale a quello appena calcolato.

2. Analizzare e dimostrare formalmente il costo

computazionale (tempo) nel caso peggiore
dell’algoritmo in figura.

3. Dimostrare il seguente Teorema:

Sia T un albero di Fibonacci di altezza h ed nh il numero dei suoi nodi. Allora h=Theta(log nh)

4. Data la coda con priorità in figura, rappresentata

attraverso heap binomiale. Mostrare come varia la
struttura dati dopo ciascuna delle seguenti operazioni

1. Insert(1)
2. Insert(3)
3. DeleteMin()
4. Delete(9)
5. DeleteMin()

5. Determinare la distanza tra le stringhe BECERO e FEROCE. Ricostruire e commentare la

sequenza di operazioni necessarie per trasformare la prima stringa nella seconda.

6. Progettare un algoritmo che, dato un generico albero memorizzato attraverso lista di puntatori ai
figli, determini il numero di nodi in ogni layer dell’albero. Un layer dell’albero (livello) consiste
dell’insieme di nodi con la stessa profondità

Esempio di output:
Livello 0: 1
Livello 1: 2
Livello 2: 3
Livello 3: 3
Livello 4: 1