![Page 1: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/1.jpg)
1
Heap binomiali
Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni:
Mucchi binomiali
Make(H) : crea uno heap vuoto
Insert(H, x) : aggiunge il nodo x allo heap
Minimum(H) : restituisce il puntatore al nodo con chiave minima
ExtractMin(H) : restituisce il puntatore al nodo con chiave minima dopo averlo tolto dallo heap
![Page 2: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/2.jpg)
2
Union(H1, H2) : riunisce due heap in uno solo
DecreaseKey(H, x, k) : cambia la chiave di x con una minore;
Delete(H, x) : toglie il nodo x;
Oltre alle precedenti operazioni fondamentali degli heap riunibili, sugli alberi binomiali definiremo anche le due ulteriori operazioni:
![Page 3: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/3.jpg)
3
Alberi binomiali
Gli heap binomiali sono insiemi di alberi binomiali
Alberi binomiali
Un albero binomiale Bk di grado k è un albero ordinato (vi è un ordine tra i figli di ogni nodo) definito ricorsivamente nel seguente modo:
L’albero binomiale B0 di grado 0 consiste in un solo nodo (radice)
![Page 4: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/4.jpg)
4
L’albero binomiale Bk di grado k > 0 consiste in due alberi binomiali di grado k - 1 legati ponendo la radice del primo come primo figlio della radice del secondo
Graficamente:
B0
Bk-1
Bk
Bk-1
![Page 5: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/5.jpg)
5
B0 B1 B2 B3 B4
![Page 6: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/6.jpg)
6
Proprietà degli alberi binomiali.L’albero binomiale Bk:
1) ha 2k nodi;2) ha altezza k;3) ha esattamente nodi a livello i;4) la radice ha grado k e tutti gli altri nodi hanno grado minore;5) se xk-1, xk-2, ..., x0 sono i figli della radice
elencati per indice decrescente da sinistra a destra allora xi è radice di un albero binomiale
Bi di grado i.
ik
![Page 7: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/7.jpg)
7
Bk
Bk-1
Bk-2
B0
B2B1
.........
Limiti dimensionaliUn albero binomiale di n = 2k nodi ha altezza e grado massimo entrambi uguali a k = log2 n
![Page 8: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/8.jpg)
8
DimostrazioneL’albero binomiale B0: 1) ha 20 = 1 nodi2) ha altezza 03) ha esattamente nodi a livello 04) la radice ha grado 0 e non ci sono altri nodi5) la radice non ha figli
10
k
Quindi le cinque proprietà sono vere per k = 0(la terza per ogni k e per i = 0)
Assumiamole vere per k-1 e dimostriamole per k
![Page 9: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/9.jpg)
9
2) l’altezza di Bk è uno in più dell’altezza di
Bk-1. Quindi Bk ha altezza k-1+1 = k;3) Sia D(k,i) il numero di nodi a livello i in Bk
1) Bk è costituito da due copie di Bk-1 e quindi
ha 2k-1 + 2k-1 = 2k nodi;
Per 0 < i < k i nodi a livello i sono i nodi a livello i di una delle due copie di Bk-1 che formano Bk più i nodi a livello i-1 dell’altra e pertanto
i
k
i
k
i
k
ikDikDikD
1
11
)1,1(),1(),(
![Page 10: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/10.jpg)
10
4) la radice di Bk ha un figlio più della radice di
Bk-1. Essa ha quindi grado k-1+1 = k;
5) il primo figlio xk-1 della radice di Bk è radice
di uno dei due Bk-1 che lo formano mentre i
figli successivi xk-2, ..., x0 sono i figli dell’altro
Bk-1 e, per ipotesi induttiva, sono quindi radici
di alberi binomiali Bk-2, ..., B0 .
![Page 11: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/11.jpg)
11
Definizione di heap binomiale
Uno heap binomiale H è un insieme di alberi binomiali tale che:
Def. mucchio binomiale
1) Ogni albero binomiale di H ha la proprietà heap: ad ogni nodo è associata una chiave e la chiave di
ciascun nodo è maggiore della chiave del padre.
2) Gli alberi binomiali in H hanno gradi distinti e crescenti
![Page 12: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/12.jpg)
12
1) H contiene l’albero binomiale Bi se e solo se bi = 1.
Proprietà degli heap binomialiSia H uno heap binomiale con n nodi in totale e sia bkbk-1...b0 la rappresentazione binaria di n. Allora:
2) H contiene al più log2 n +1 alberi.
![Page 13: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/13.jpg)
13
Dimostrazione.Sia H uno heap binomiale con n nodi in totale e sia bkbk-1...b0 la rappresentazione binaria di n. Allora:
1) un albero binomiale Bi in H contiene 2i nodi e quindi n è somma di potenze di 2 distinte. L’unico modo in cui si può esprimere n come somma di potenze di 2 distinte è
(pensateci con le potenze di 10)
k
i
iibn
02
2) Se lo heap contenesse Bk con 2k > n, eccederebbe il numero di nodi consentito. Quindi, al più usa tutti gli alberi da B0 a Bk con k = log2 n
![Page 14: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/14.jpg)
14
10cima[H]
27
38
8 14 29
6
18
2512
1
11 17
I nodi hanno i seguenti campi:key : la chiave;parent : puntatore al padrechild : puntatore al primo figliosibling : puntatore al fratello destrodegree : numero di figli.oltre ad eventuali altri campi ausiliari
![Page 15: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/15.jpg)
15
sibling
parent
child
cima[H] 10 0 1 2
12 1
18 0
25 0 8 2
11 1
27 0
17 0
6 3
14 1
18 0
29 0
![Page 16: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/16.jpg)
16
Minimum(H) PRE: H non è vuoto
x cima[H], kmin key[x] while sibling[x] nil do x sibling[x] if kmin > key[x] then kmin key[x] return kmin
La funzione Minimum è:
Siccome ci sono al più log2 n +1 alberi essa richiede tempo O(log n).
Minimum
![Page 17: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/17.jpg)
17
Link(y, z) PRE: y e z sono radici di alberi binomiali
dello stesso grado
parent[y] z sibling[y] child[z] child[z] y degree[z] degree[z] + 1
Link
La funzione ausiliaria Link è usata da molte altreAggiunge y come primo figlio di z. Richiede tempo costante O(1).
Nel seguito, assumiamo di avere una funzione Union() che fonde due heap in tempo O(log n).
![Page 18: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/18.jpg)
18
Insert(H, x) parent[x] nil, sibling[x] nil child[x] nil , degree[x] 0 cima[H1] x Union(H,H1)
La funzione Insert è:
Siccome Union richiede tempo O(log n) anche Insert richiede tempo O(log n).
Insert
![Page 19: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/19.jpg)
19
10cima[H]
27
38
8 14 29
6
18
2512
1
11 17
10cima[H]
27
38
8 14 29
6
18
2512
1
11 17
x
ExtractMin
![Page 20: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/20.jpg)
20
10cima[H]
27
38
8 14 29
6
18
2512
1
11 17
x
10cima[H]
27
38
8 14 29
6
18
25 12
1
11 17
x
cima[H1]
![Page 21: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/21.jpg)
21
10cima[H]
27
38
8 14 29
6
18
25 12
1
11 17
x
cima[H1]
cima[H]
27
38
8 14 29
6
18
12
1
11 17
x
25
10
![Page 22: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/22.jpg)
22
ExtractMin(H) x cima[H], if x = nil then return nil z nil, kmin key[x], y sibling[x] while y nil do cerca la radice minima
if kmin > key[y] then z x, kmin key[y] x y, y sibling[x] if z = nil then la radice minima è la prima
x cima[H], cima[H] sibling[x] else la radice minima è quella che segue z
x sibling[z], sibling[z] sibling[x]
La funzione ExtractMin è: ExtractMin
![Page 23: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/23.jpg)
23
cima[H1] nil costruisce un heap H1 con i figli di x
while child[x] nil do y child[x] child[x] sibling[y] parent[y] nil sibling[y] cima[H1] cima[H1] y Union(H,H1) unisce i due heap
return x
![Page 24: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/24.jpg)
24
Il primo ciclo while percorre la lista delle radici ed ha quindi complessità O(log n).
Il secondo ciclo while percorre la lista dei figli di una radice. Siccome il grado è O(log n) anche tale ciclo ha complessità O(log n).
Infine Union richiede tempo O(log n) e quindi anche ExtractMin richiede tempo O(log n).
![Page 25: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/25.jpg)
25
DecreaseKey(H, x, k) if k > key[x] then errore “la nuova chiave non è minore della vecchia” key[x] k y parent[x] while y nil and key[y] > key[x] do k key[x], key[x] key[y], key[y] k “scambia anche eventuali campi associati” x y, y parent[x]
La funzione DecreaseKey è:
Siccome l’altezza è O(log n) anche DecreaseKey richiede tempo O(log n).
DecreaseKey
![Page 26: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/26.jpg)
26
Delete(H, x)
DecreaseKey(H, x, -) ExtractMin(H)
La funzione Delete è:
Siccome sia DecreaseKey che ExtractMin hanno complessità O(log n) anche Delete richiede tempo O(log n).
Delete
![Page 27: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/27.jpg)
27
La logica è semplice (l’implementazione meno…)
Percorre le due liste delle radici e le fonde nella prima• quando un albero Bi c’è e l’altro no, lo aggiunge• quando ci sono entrambi, aggancia uno all’altro,
ottenendo un solo albero Bi+1
• se già esisteva un Bi+1 aggancia un albero all’altro,ottenendo un solo albero Bi+2
• ripete gli accorpamenti finché necessario per eliminare i doppioni
Union
Union
![Page 28: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/28.jpg)
28
Union(H1,H2) x cima[H1], xp nil y cima[H2], cima[H2] = nil while x nil and y nil do I° while
Sia x la radice corrente in H1 e y quella in H2Procediamo scorrendo H1 con x e sganciando via via y finché non abbiamo scorso interamente le due liste
Union
xp è la radice che precede x (per manipolare la lista H1) ys è la radice che segue y (per scorrere H2 dopo aver sganciato y
![Page 29: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/29.jpg)
29
xxp
y
xxp
y
Caso 1.
Finché l’albero in y è più grosso di quello in x sposto avanti x…
if degree[y] > degree[x] then caso 1
xp x, x sibling[x]
![Page 30: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/30.jpg)
30
Caso 2.
xxp
y
xxp
y ys
else if degree[y] < degree[x] then caso 2 ys sibling[y] if xp = nil then cima[H1] y else sibling[xp] y sibling[y] x, xp y y ys
Quando l’albero in y è più piccolo di quello in x, lo aggancio fra xp e x
![Page 31: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/31.jpg)
31
else caso 3: degree[y] = degree[x]
ys sibling[y]
Caso 3
Se i due alberi sono uguali, vanno fusiIntanto, prepariamo il successivo valore di y…
![Page 32: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/32.jpg)
32
Caso 3.1.
xxp
y
7
4
xxp
y
7
4
ys
if key[x] > key[y] then caso 3.1xs sibling[x]Link(x,y)if xp = nil then cima[H1] yelse sibling[xp] ysibling[y] xs x y, y ys
Se x ha chiave più alta, aggancio x a y e inserisco y nella lista della radici(due casi secondo che sia in cima alla lista o no)
![Page 33: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/33.jpg)
33
Caso 3.2.
xxp
y
7
4
xxp
y
4
7
ys
else caso 3.2
Link(y,x)y ys
Se x non ha chiave più alta, aggancio y a x
![Page 34: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/34.jpg)
34
xs sibling[x] while xs nil and degree[x] = degree[xs] do II° while
Dopo la fusione, l’albero in x e quello in xs possono essere di ugual dimensione. Finché è così, li fondo
Ancora una volta, abbiamo due casi: 1. chiave di x più alta di quella di xs
(caso 3.3: aggancio di xs a x e inserimento di x nella lista)2. chiave di x non più alta di quella di xs
(caso 3.4: semplice aggancio di x a xs)
![Page 35: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/35.jpg)
35
xxp4 7
xs
Caso 3.4.
Caso 3.3.
xxp7 4
xs
xxp
7
4
xs
if key[x] > key[xs] then caso 3.3Link(x,xs)if xp = nil then cima[H1] xselse sibling[xp] xsx xs
else caso 3.4sibling[x] sibling[xs]Link(xs,x)
xs sibling[x]
![Page 36: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/36.jpg)
36
if y nil then if xp = nil then cima[H1] y else sibling[xp] y
Arrivati in fondo ad H1, se in H2 c’è qualcos’altro, va direttamente appeso ad H1(due sottocasi, secondo che H1 sia vuota o no)
![Page 37: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/37.jpg)
37
Siccome m1, m2 ed m sono tutti O(log n) anche Union richiede tempo O(log n).
Ad ogni esecuzione del ciclo while interno il numero totale di alberi diminuisce di uno. Quindi esso viene eseguito al più m1 + m2 - m volte.
Siano m1 ed m2 il numero di alberi contenuti nei due heap da unire, m quello dello heap risultante
Il ciclo while più esterno si esegue al più m1 + m2 volte
![Page 38: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/38.jpg)
38
Operazione Complessità Make (1) Insert O(log n) Minimum O(log n) ExtracMin O(log n) Union O(log n) DecreaseKey O(log n) Delete O(log n)
![Page 39: 1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap](https://reader035.vdocuments.pub/reader035/viewer/2022062701/5542eb58497959361e8c3a7d/html5/thumbnails/39.jpg)
39
Operazione Complessità ammortizzata Make (1) Insert (1) Minimum (1) ExtractMin O(log n) Union (1) DecreaseKey (1) Delete O(log n)
Esiste una struttura dati, i mucchi di Fibonacci, in cui le stesse operazioni si eseguono con le seguenti complessità ammortizzate.