Aggiunge Heap di Fibonacci (senza dim per ora)

content/Alberi Binomiali Non Ordinati.md

@@ -3,3 +3,45 @@ tags:
   - Algoritmi/PrimaProva
   - Algoritmi/StruttureDati
 ---
+# Alberi Binomiali Non Ordinati
+
+Implementano gli [[Heap di Fibonacci]].
+
+>[!def] Definizione
+>$\forall\ k \in \mathbb{N}\ \exists \text{ un albero binomiale non ordinato } U_{k} \text{ di grado } k$, definito in base alla seguente ricorsione:
+>- $U_{0}$ è l'albero formato da un solo nodo;
+>- Dato $U_{k-1}$ definiamo $U_{k}$ combinando due copie di $U_{k-1}$ nella seguente maniera:
+> ![[Pasted image 20231219225217.png|256]]
+
+## Lemma (Proprietà degli alberi binomiali NON Ordinati)
+
+Per ogni $k=0,1,2\dots$ valgono le segu\enti proprietà: 
+
+1. $U_{k}$ ha $2^k$ nodi;
+2. L'altezza di $U_{k}$ è $k$;
+3. $U_{k}$ ha $\displaystyle\binom{k}{i}$ a profondità $i\ (i=0,1,\dots,k)$
+4. La radice di $U_{k}$ ha grado $k$ ed ogni altro nodo in $U_k$ ha grado $<k$.
+   Inoltre, i figli della radice di $U_{k}$ sono radici di $U_{k-1},U_{k-2},\dots,U_{2},U_{1},U_{0}$ **in un qualsiasi ordine** $\textcolor{red}{(unico\ cambiamento)}$. 
+
+- Si osservi che da questo lemma segue immediatamente che $D(n)=O(\log n)$, almeno quando l'heap è formato soltanto da alberi binomiali non ordinati.
+- La strategia di mantenimento degli Heap di Fibonacci prevede di <ins>ritardare il più possibile il lavoro di ristrutturazione dell'heap</ins>.
+
+<ins>DImostrazione</ins> per induzione 
+
+Caso Base: $k=0$ 
+
+1. $U_{0}$ ha $1=2^0$ nodi.
+2. L'altezza di $U_{0}$ è $0$
+3. $U_{0}$ ha $1=\displaystyle\binom{0}{0}$ nodi a profondità $0$
+4. La radice di $U_{0}$ ha grado $0$
+
+Passo Induttivo: Supponiamo che il Lemma sia vero per $k-1$, con $k\geq1$
+1. $U_{k}$ ha $\#(U_{k-1}+)+\#(U_{k-1})=2\cdot2^{k-1}=2^k$ nodi.
+2. L'altezza di $U_{k}$ è $(k-1)+1=k$
+3. Sia $1 \leq i \leq k-1$, il numero di nodi di $U_{k}$ a profondità $i$ è uguale a:  
+
+   $\displaystyle\binom{k-1}{i}+\binom{k-1}{i-1}=\binom{k}{i}$
+   Inoltre, $U_{k}$ ha $\displaystyle\binom{k}{0}=1$ nodi a profondità 0, quindi avrà $\displaystyle\binom{k}{k}$ nodi a profondità $k$. 
+4. La radice di $U_{k}$ ha grado $degree{U_{k-1}}+1 = k
+	- Inoltre ciascun altro nodo appartiene ad un $U_{k-1}$ e pertanto per ipotesi induttiva ha grado $\leq k-1$, cioè $<k$.
+	- Il primo figlio della radice di $U_{k}$ è radice di $U_{k-1}$. Inoltre, per ipotesi induttiva, I successivi $k-1$ figli della radice di $U_{k}$ sono radici di $U_{k-2},...,U_1,U_{0}. \quad \blacksquare$

content/Esami/Schema Esercizi Prima Prova.md

@@ -45,7 +45,7 @@ sempre quello mbare
 # Heap di Fibonacci
 
 - Indicare operazioni supportate, e la loro complessità.
-- Sia $x$ un nodo di grado $k$ in un heap di Fibonacci e siano $y_{1},\dots,y_{k}$ i figli di $x$ nell'ordine in cui sono stati innestati in $x$. Quale limitazione inferiore è possibile dare per il grado degree$(y_{i})$. Perché? [[Heap di Fibonacci#Stima di D(n)]]
+- Sia $x$ un nodo di grado $k$ in un heap di Fibonacci e siano $y_{1},\dots,y_{k}$ i figli di $x$ nell'ordine in cui sono stati innestati in $x$. Quale limitazione inferiore è possibile dare per il grado degree$(y_{i})$. Perché? [[Heap di Fibonacci#Lemma 3|Lemma 3]]
 - Fornire (e dimostrare) una minorazione dei gradi dei figli di ciascun nodo (**LEMMA**)
 - Stabilire se esistono heap di Fibonacci dati nel compito
 

content/Heap di Fibonacci.md

@@ -7,6 +7,87 @@ draft: false
 ---
 # Heap di Fibonacci
 
+Uno Heap di Fibonacci è una collezione di alberi con la proprietà Heap. 
+
+Gli alberi di uno Heap di Fibonacci non devono necessariamente essere binomiali. 
+
+![[Pasted image 20231219223345.png|256]]
+
+- $p[x]$: Padre;
+- $left[x]:$ Fratello sinistro;
+- $right[x]:$ Fratello destro;
+- $child[x]:$ un figlio;
+- $degree[x]:$ numero di figli;
+- $mark[x]:$ indica se il nodo $x$ ha perduto un figlio dall'ultima volta in cui $x$ è diventato figlio di un altro nodo.
+
+Inoltre:
+
+- $min[H]:$ punta al minimo, indica la radice contenente la chiave minima e dà accesso alla struttura;
+- $n[H]:$ contiene il numero di nodi in H.
+
+>[!example]- Esempio
+>![[Pasted image 20231219224018.png|512]]
+
+## Funzione Potenziale
+
+$\Phi(H)=t(H)+2m(H)\geq 0$
+
+Dove:
+- t(H): numero alberi nella lista delle radici di H;
+- m(H): numero nodi marcati in H
+- Sia $\{H_{i}\}_{i \in I}$ una collezione finita di Heap, poniamo: $\Large\Phi(\{H_{i}\}_{i \in I})=\displaystyle\sum_{i \in I}\Phi(H_{i})\geq 0 = \Phi(\emptyset)$
+
 # Stima di D(n)
 
-# Lemma Minorazione gradi figli
+$\large D(n)$ è il massimo grado di un nodo. 
+
+- L'analisi verrà effettuata in funzione di un upper bound $D(n)$ sul massimo grado di un nodo qualunque in uno heap con n nodi.
+- Dimostreremo che si ha: $\large \textcolor{red}{D(n)=O(\log n)}$
+
+## Operazioni presenti e mancanti
+
+Se vengono eseguite <ins>SOLO</ins> operazioni del tipo:
+- Make-Heap; $\qquad O(1)$
+- Insert; $\qquad O(1)$
+- Minimum; $\qquad O(1)$
+- Extract-Min; $\qquad O(\log n)=O(D(n))$
+- Union. $\qquad O(1)$
+
+Ciascuno Heap di Fibonacci è rappresentabile come collezione di alberi binomiali non ordinati. 
+
+$D^*(n)=$ massimo grado di un nodo in un heap di fibonacci con $n$ nodi costruito senza mai usare le operazioni di **Decrease-Key** e **Delete**.
+
+Vedremo che $D^*(n)\leq D(n)$. Inoltre, i costi di complessità sono ammortizzati.
+
+## Lemma 3 (quello che c'è all'esame da qui in poi, ndr)
+
+(Abbiamo saltato i primi due perché indicano proprietà dei numeri di fibonacci). 
+
+Sia $x$ un nodo in un heap di fibonacci e sia $grado(x)=k$. 
+
+Siano $y_{1},y_{2},\dots,y_{k}$ i figli di $x$ nell'ordine in cui sono stati innestati in $x$. 
+
+Allora, $grado[y_{i}]\geq i-2,$ per $i=3,4,\dots,k$
+
+<ins>Dimostrazione</ins>
+
+...
+
+## Altro Lemma
+
+Sia x un nodo in uno heap di fibonacci, e sia $grado[x]=k$. 
+
+Allora $size(x)\geq F_{k+2},$ dove $size(x)$ è il numero di nodi nel sottoalbero radicato in $x$.
+
+<ins>Dimostrazione</ins>
+
+...
+
+## Corollario 1
+
+$\Large size[x]\geq \Phi^{grado[x]}$
+## Corollario 2
+
+$\Large D(n)\leq \left\lfloor {\log_{\Phi}n} \right\rfloor,$ da cui $\Large D(n)=O(\log n)$ .
+
+<ins>Dimostrazione</ins>