CORSO DI
ALGORITMI E STRUTTURE DATI
Homeworks set #1
Valerio Mennillo
Alessia Trapani
M63001277
M63001278
Esercizio 1.1 Notazione asintotica

𝒇(𝒏) = 𝑶(𝒇(𝒏)𝟐 )?
1
1
Cerchiamo un controesempio. Supponiamo 𝑓 (𝑛) = 𝑛 e 𝑓 (𝑛)2 = 𝑛2.
𝑓(𝑛)
Se calcoliamo 𝑓(𝑛)2 = 𝑛, notiamo subito che 𝑛 è una funzione illimitata e quindi in questo caso 𝑓(𝑛) ≠
𝑂(𝑓(𝑛)2 ) (possiamo arrivare allo stesso risultato applicando la definizione: non riusciremo a trovare una
costante 𝑐 affinché la disuguaglianza sia valida per 𝑛 sufficientemente grande).
Considerando, però, 𝑓 (𝑛) = 𝑛 e 𝑓 (𝑛)2 = 𝑛2 , riusciamo a trovare 𝑐 tale che 0 ≤ 𝑛 ≤ 𝑐𝑛2 per 𝑛
sufficientemente grande. Infatti, per 𝑐 > 0 𝑛 = 𝑂(𝑛2 ) ⇒ 𝑓 (𝑛) = 𝑂(𝑓(𝑛)2 ).
Possiamo concludere dicendo che 𝑓 (𝑛) = 𝑂(𝑓(𝑛)2 ) è a volte vera, dipende da 𝑓(𝑛).
Nota: se avessimo considerato solo funzioni crescenti, la relazione sarebbe stata sempre vera.

𝒇(𝒏) + 𝑶(𝒇(𝒏)) = 𝜣(𝒇(𝒏))?
Consideriamo 𝑓 (𝑛) + 𝑔(𝑛) per 𝑔(𝑛) = 𝑂(𝑓(𝑛)). Dato che abbiamo supposto 𝑔(𝑛) = 𝑂(𝑓(𝑛)), allora
esiste una costante positiva 𝑐 tale che 0 ≤ 𝑔(𝑛) ≤ 𝑐𝑓(𝑛) per 𝑛 sufficientemente grande.
Fatte queste assunzioni possiamo dire che
𝑓 (𝑛) ≤ 𝑓(𝑛) + 𝑔(𝑛) ≤ (𝑐 + 1)𝑓(𝑛)
per 𝑛 sufficientemente grande.
Possiamo concludere dicendo che 𝑓(𝑛) + 𝑂(𝑓(𝑛)) = 𝛩(𝑓(𝑛)) è sempre vera.

𝒇(𝒏) = 𝛀(𝒈(𝒏)) 𝒆 𝒇(𝒏) = 𝒐(𝒈(𝒏))?
Se 𝑓(𝑛) = Ω(𝑔(𝑛)), allora esiste una costante positiva 𝑐1 e 𝑛1 tale che 𝑓(𝑛) ≥ 𝑐1 𝑔(𝑛) per 𝑛 > 𝑛1 .
Se 𝑓(𝑛) = 𝑜(𝑔(𝑛)), allora per ogni costante positiva 𝑐 e 𝑛𝑜 𝑓(𝑛) < 𝑐𝑔(𝑛) per 𝑛 > 𝑛𝑜 .
Per far valere entrambe contemporaneamente dovremmo avere che per 𝑛 > 𝑚𝑎𝑥(𝑛1 , 𝑛𝑜 )
𝑐1 𝑔(𝑛) ≤ 𝑓(𝑛) < 𝑐𝑔(𝑛)
Se 𝑐 = 𝑐1 (la relazione o-piccolo vale se è verificata per ogni 𝑐),
𝑐1 𝑔(𝑛) ≤ 𝑓 (𝑛) < 𝑐1 𝑔(𝑛)
Ciò è impossibile, quindi 𝑓(𝑛) = Ω(𝑔(𝑛)) 𝑒 𝑓(𝑛) = 𝑜(𝑔(𝑛)) non è mai vera.
Esercizio 1.2 Complessità
Dimostriamo che per qualsiasi 𝑎 e 𝑏, con 𝑏 > 0, (𝑛 + 𝑎)𝑏 = 𝛩(𝑛𝑏 ). Per fare ciò troviamo un limite superiore
e un limite inferiore.

(𝑛 + 𝑎 )𝑏 = 𝑂(𝑛𝑏 )
Troviamo 𝑐1 > 0 tale che (𝑛 + 𝑎)𝑏 ≤ 𝑐1 (𝑛𝑏 ) per 𝑛 sufficientemente grande.
(𝑛 + 𝑎)𝑏 ≤ (𝑛 + |𝑎|)𝑏 ≤ (𝑛 + 𝑛)𝑏 = (2𝑛)𝑏
(𝑛 + 𝑎)𝑏 = 𝑂(𝑛𝑏 )
𝑝𝑒𝑟 𝑛 ≥ |𝑎|
𝑝𝑒𝑟 𝑐1 = 2𝑏 𝑒 𝑛 ≥ |𝑎 |

(𝑛 + 𝑎 )𝑏 = 𝛺(𝑛𝑏 )
Troviamo 𝑐2 > 0 tale che (𝑛 + 𝑎)𝑏 ≥ 𝑐2 (𝑛𝑏 ) per 𝑛 sufficientemente grande.
𝑛 𝑏
(𝑛 + 𝑎 )𝑏 ≥ (𝑛 − |𝑎|)𝑏 ≥ ( )
𝑝𝑒𝑟 𝑛 ≥ 2|𝑎|
2
(𝑛 + 𝑎)𝑏 = 𝛺(𝑛𝑏 )
Dato che 𝑓(𝑛) = 𝛩(𝑔(𝑛))
⇔
𝑝𝑒𝑟 𝑐2 = 2−𝑏 𝑒 𝑛 ≥ 2|𝑎|
𝑓 (𝑛) = 𝑂(𝑔(𝑛)) 𝑒 𝑓(𝑛) = 𝛺(𝑔(𝑛))
(𝑛 + 𝑎)𝑏 = 𝛩(𝑛𝑏 )
con 𝑐1 = 2𝑏 , 𝑐2 = 2−𝑏 e per 𝑛 ≥ 2|𝑎|
Esercizio 1.3 Complessità

𝟐𝒏+𝟏 = 𝑶(𝟐𝒏 )?
Affinché 𝑓 (𝑛) = 𝑂(𝑔(𝑛)), deve esistere una costante positiva 𝑐 tale che 2𝑛+1 ≤ 𝑐2𝑛 per 𝑛
sufficientemente grande. Cerchiamo 𝑐.
2𝑛+1 ≤ 𝑐2𝑛
2 ∙ 2𝑛 ≤ 𝑐2𝑛
La costante esiste, 𝑐 = 2, e quindi 2𝑛+1 = 𝑂(2𝑛 ) è vero.

𝟐𝟐𝒏 = 𝑶(𝟐𝒏 )?
Affinché 𝑓 (𝑛) = 𝑂(𝑔(𝑛)), deve esistere una costante positiva 𝑐 tale che 22𝑛 ≤ 𝑐2𝑛 per 𝑛
sufficientemente grande. Cerchiamo 𝑐.
22𝑛 ≤ 𝑐2𝑛
2𝑛 ∙ 2𝑛 ≤ 𝑐2𝑛
Non esiste una costante 𝑐 tale che 𝑐 ≥ 2𝑛 e quindi 22𝑛 = 𝑂(2𝑛 ) non è vero.
Esercizio 1.4 Ricorrenze

𝒏
Fornire il limite inferiore e superiore per 𝑻(𝒏) = 𝟐𝑻 ( 𝟑) + 𝒏 𝒍𝒈 𝒏
Applichiamo il terzo caso del metodo dell’esperto.
𝑎=2
𝑏=3
𝑓 (𝑛) = 𝑛 lg 𝑛
𝑛𝑙𝑜𝑔𝑏 𝑎 = 𝑛𝑙𝑜𝑔3 2
Verifichiamo le condizioni del teorema:
1. 𝑓(𝑛) = 𝛺(𝑛𝑙𝑜𝑔𝑏 𝑎+𝜖 ) per 𝜖 > 0
𝑛 𝑙𝑔 𝑛 = 𝑓 (𝑛) = 𝛺(𝑛𝑙𝑜𝑔3 2+𝜖 ) per 𝜖 ≈ 0.4
𝑛
2. 𝑎𝑓 (𝑏 ) ≤ 𝑐𝑓(𝑛) per una data 𝑐 < 1 ed 𝑛 sufficientemente grande
𝑛
𝑛
2
2 ( 3 ) 𝑙𝑔 ( 3 ) ≤ 3 𝑛 𝑙𝑔 𝑛
2
per 𝑐 = 3 < 1
Entrambe le condizioni sono valide, quindi 𝑇 (𝑛) = 𝛩(𝑛 𝑙𝑔 𝑛)

𝒏
Fornire il limite inferiore e superiore per 𝑻(𝒏) = 𝟑𝑻 ( 𝟓) + 𝒍𝒈𝟐 𝒏
Applichiamo il primo caso del metodo dell’esperto.
𝑎=3
𝑏=5
𝑓(𝑛) = lg 2 𝑛
𝑛𝑙𝑜𝑔𝑏 𝑎 = 𝑛𝑙𝑜𝑔5 3
Dobbiamo verificare che 𝑓 (𝑛) = 𝑂(𝑛𝑙𝑜𝑔𝑏 𝑎−𝜖 ) per 𝜖 > 0
𝑙𝑔2 𝑛 = 𝑓 (𝑛) = 𝑂(𝑛𝑙𝑜𝑔3 2−𝜖 ) per 0 < 𝜖 < 𝑙𝑜𝑔5 3 = 0.682
La condizione è valida, quindi 𝑇(𝑛) = 𝛩(𝑛𝑙𝑜𝑔5 3 )
Esercizio 1.5 Ricorrenze
Dimostriamo tramite albero di ricorrenza che la soluzione della ricorrenza
𝒏
𝟐
𝑻(𝒏) = 𝑻 ( ) + +𝑻 ( 𝒏) + 𝒄𝒏
𝟑
𝟑
è Ω(n log n).
1
2
L’albero che ne viene fuori non è bilanciato perché vi è un percorso più veloce (a sinistra, (3 < 3),) relativo ai
sottoproblemi più piccoli. Sommando i termini di ogni livello, notiamo che il costo è 𝑐𝑛 per tutti i livelli
completi. Quando abbiamo livelli incompleti, il costo sarà ≤ 𝑐𝑛.
Per definire il limite inferiore vado, dunque, a considerare il percorso più breve visto che terminerà prima,
1 𝑖
ovvero quello più a sinistra che ha una dimensione pari a ( ) 𝑛. La dimensione sarà pari a 1 quando
3
1 𝑖
( ) 𝑛=1
3
⇒
𝑖 = 𝑙𝑜𝑔3 𝑛
𝑇(𝑛) sarà sicuramente maggiore del costo fino all’albero log 3 𝑛 quindi
𝑙𝑜𝑔3 𝑛
𝑇 (𝑛) ≥ ∑ 𝑐𝑛 = 𝑐𝑛(𝑙𝑜𝑔3 𝑛 + 1) ≥ 𝑐𝑛 𝑙𝑜𝑔3 𝑛 =
𝑖=0
𝑐
𝑛 𝑙𝑜𝑔 𝑛
𝑙𝑜𝑔 3
⇒
𝑇(𝑛) = 𝛺(𝑛 𝑙𝑜𝑔 𝑛)
Homework 1.1. Inversioni

Elencate le cinque inversioni dell’array (2, 3, 8, 6 ,1)
1. (1,5);
2. (2,5);
3. (3,4);
4. (3,5);
5. (4,5).

Quale array con elementi estratti dall’insieme {𝟏, 𝟐, … 𝒏} ha più inversioni? Quante inversioni ha?
L’array con più inversioni è quello che presenta gli elementi in ordine decrescente:
[𝑛 𝑛 − 1 𝑛 − 2 … 2 1]
Calcoliamo il numero di inversioni partendo dal primo elemento (𝑛) e andando avanti:
- 𝑛 avrà 𝑛 − 1 inversioni;
- 𝑛 − 1 avrà 𝑛 − 2 (𝑛 − 1 − 1) inversioni;
- …
- 2 avrà 1 inversione;
- 1 avrà 0 inversioni.
Possiamo quindi scrivere una sommatoria per ottenere il numero massimo di inversioni:
𝑛
𝑛
𝑛
∑𝑖 − 1 = ∑𝑖 −∑1 =
𝑖=1
𝑖=1
𝑖=1
𝑛(𝑛 + 1)
𝑛(𝑛 − 1)
−𝑛 =
2
2

Qual è la relazione tra il tempo di esecuzione di Insertion Sort e il numero di inversioni nell’array di
input?
Il numero massimo di inversioni si verifica quando il vettore è in ordine decrescente che coincide anche
con il caso peggiore di Insertion Sort. Il tempo di esecuzione di Insertion Sort è strettamente legato al
numero di volte in cui viene eseguito il ciclo while e, se abbiamo un alto numero di inversioni,
andremmo ad eseguire tale ciclo un elevato numero di volte. Di conseguenza, più inversioni ci sono in
un array, più tempo impiegherà Insertion Sort ad ordinarlo.

Create un algoritmo che determina il numero di inversioni in una permutazione di n elementi nel
tempo 𝚯(𝒏 𝐥𝐨𝐠 𝒏) nel caso peggiore.
int Merge-Sort-Inversion(A,p,r)
invers ⟵ 0
if p<r
q ⟵ ⌊(p+r)/2⌋
invers ⟵ invers + Merge-Sort(A,p,q)
invers ⟵ invers + Merge-Sort(A,q+1,r)
invers ⟵ invers + Merge (A,p,q,r)
return invers
int Inversions-Counter(A,p,q,r)
n1 ⟵ q-p+1
n2 ⟵ r-q
//Create L[1 … n1+1] and R[1 … n2+1]
for i ⟵ 1 to n1
do L[i] ⟵ A[p+i-1]
for j ⟵ 1 to n2
do R[j] ⟵ A[q+j]
L[n1+1] ⟵ R[n2+1] ⟵ ∞
i⟵j⟵1
invers ⟵ 0
for k ⟵ p to r
do if L[i]≤R[j]
then A[k] ⟵ L[i]
i ⟵ i+1
else
then A[k] ⟵ R[i]
invers ⟵ invers +n1-i+1
j ⟵ j+1
return invers
Partendo dal Merge-Sort, è stato costruito un algoritmo che identifica le inversioni in A. Il principio su
cui si basa è che il numero di inversioni viene incrementato solo se un elemento del sottoalbero di
destra viene scelto per essere depositato nell’array superiore.
Visto che i sottoarray sono già ordinati, possiamo incrementare il numero di inversioni di un numero
pari a tutti i restanti elementi del sottoarray di sinistra.
Homework 1.2 Unimodal
int Unimodal(A)
first ⟵ 0
last ⟵ lenght[A]-1
while first <= last
do midpoint ⟵ ⌊(first + last)/2⌋
if midpoint + 1 > last
then return midpoint
if midpoint - 1 > first
then return midpoint
if A[midpoint] > A[midpoint-1] and A[midpoint] > A[midpoint+1]
then return midpoint
if A[midpoint] > A[midpoint+1]
then last ⟵ midpoint-1
else first ⟵ midpoint+1
Il ragionamento alla base di questo algoritmo è molto simile a quello utilizzato per la ricerca binaria. Si
prende l’elemento posto al centro dell’array e si controlla la relazione di tale elemento rispetto al
precedente e al successivo. Si possono manifestare 3 casi:



L’elemento centrale è maggiore di entrambi: l’elemento centrale è il massimo.
L’elemento centrale è maggiore del successivo ma non del precedente: la ricerca viene ripetuta sugli
elementi precedenti (da 0 a midpoint-1).
L’elemento centrale è minore del successivo: la ricerca viene ripetuta sugli elementi successivi (da
midpoint+1 a n).
Il tempo di esecuzione dipende da quante volte viene eseguita la condizione del while nel caso peggiore. Il
corpo del while viene eseguito fintanto che lo spazio di ricerca è non vuoto.
Inizialmente lo spazio di ricerca ha dimensione 𝑛. Ad ogni esecuzione del while esso viene al più dimezzato,
quindi dopo 𝑖 iterazioni avrò uno spazio di ricerca pari a
𝑛
𝑛
2𝑖
. Considerando il caso peggiore, la dimensione
sarà pari a 1 quando 2𝑖 = 1, ovvero 𝑖 = 𝑙𝑔 𝑛.
Nel caso peggiore, il corpo del while viene eseguito lg 𝑛 volte. Per tale motivo, l’algoritmo Unimodal ha una
complessità pari a 𝑂(𝑙𝑔 𝑛).
Homework 1.3 Ricorrenze

𝒏
Fornire il limite inferiore e superiore per 𝑻(𝒏) = 𝑻 ( 𝟐) + 𝟐𝒏
Applichiamo il terzo caso del metodo dell’esperto.
𝑎=1
𝑏=2
𝑓 (𝑛) = 2𝑛
𝑛𝑙𝑜𝑔𝑏 𝑎 = 𝑛𝑙𝑜𝑔2 1 = 𝑛0 = 1
Verifichiamo le condizioni del teorema:
3. 𝑓(𝑛) = 𝛺(𝑛𝑙𝑜𝑔𝑏 𝑎+𝜖 ) per 𝜖 > 0
2𝑛 = 𝑓(𝑛) = 𝛺(𝑛𝑙𝑜𝑔2 1+𝜖 ) = 𝛺 (𝑛) per 𝜖 = 1
𝑛
4. 𝑎𝑓 (𝑏 ) ≤ 𝑐𝑓(𝑛) per una data 𝑐 < 1 ed 𝑛 sufficientemente grande
2𝑛/2 ≤ 𝑐2𝑛
1
2𝑛/2 ≤ 2 2𝑛 = 2𝑛−1
1
per 𝑐 = 2 < 1 e 𝑛 ≥ 2
Entrambe le condizioni sono valide, quindi 𝑇 (𝑛) = Θ(2𝑛 )