piccoli edit ad analisi ammortizzata e aggregazione, aggiunge metodo …

…accantonamenti

content/Analisi Ammortizzata.md

@@ -10,6 +10,7 @@ Si determina un tempo complessivo $T(n)$ che viene in qualche modo ripartito tra
 $\dfrac{T(n)}{n}:\text{costo ammortizzato per operazione.}$
 
 La stima ottenuta non è probabilistica, si tratta di una media nel caso peggiore.
+In generale, ha senso se il costo di tutte le operazioni può essere appunto ammortizzato su più operazioni. Non serve a nulla se abbiamo sempre l'operazione peggiore.
 
 **Tre Metodi**:
 - [[Metodo dell'Aggregazione]]

content/Contatore binario.md

@@ -31,6 +31,8 @@ Costo di $\color{red}n$ incrementi = $\color{red}nO(k) = O(nk)$
 
 Anche in questo caso c'è un'analisi sovrabbondante.
 
+>[!warning] Il contatore è inizialmente nullo a meno che non venga specificato altrimenti
+
 ## Contatore Binario con [[Metodo dell'Aggregazione|Aggregazione]]
 
 Supponiamo che esistano due operazioni:
@@ -41,16 +43,12 @@ $Reset \quad 1 \longrightarrow 0$ </br>
 E che il contatore sia inizialmente nullo.
 
 Notiamo che su $n$ operazioni di tipo $\text{Increment}$:
-- $A[0]$ cambia $n$ volte
-- $A[1]$ cambia $\left\lfloor {\dfrac{n}{2}} \right\rfloor$ volte
-- $A[2]$ cambia $\left\lfloor {\dfrac{n}{2^2}} \right\rfloor$ volte
-- $A[3]$ cambia $\left\lfloor {\dfrac{n}{2^3}} \right\rfloor$ volte
+- $A[0]$ cambia $n$ volte, indica il bit del pari/dispari.
+- $A[1]$ cambia $\left\lfloor {\dfrac{n}{2}} \right\rfloor$ volte, cioè una volta sì e una no.
+- $A[2]$ cambia $\left\lfloor {\dfrac{n}{2^2}} \right\rfloor$ volte, ogni 4 volte.
+- $A[3]$ cambia $\left\lfloor {\dfrac{n}{2^3}} \right\rfloor$ volte.
 - ...
-- $A[i]$ cambia $\left\lfloor {\dfrac{n}{2^i}} \right\rfloor$ volte
-
-ciao
-
-**Esempio Contatore**
+- $A[i]$ cambia $\left\lfloor {\dfrac{n}{2^i}} \right\rfloor$ volte.
 $$ \Large
 
 \begin{flalign*} \\
@@ -70,7 +68,33 @@ $$ \Large
 
 $$
 
+Otteniamo:
+$T(n)=n+\left\lfloor {\dfrac{n}{2}} \right\rfloor+\dots+\left\lfloor {\dfrac{n}{2^{k-1}}} \right\rfloor=$ <br>
+Otteniamo una serie geometrica di ragione $\dfrac{1}{2}$ <br>
+$= \displaystyle\sum^{k-1}_{i=0}\left\lfloor {\dfrac{n}{2^i}} \right\rfloor\leq \sum^{k-1}_{i=0}{\dfrac{n}{2^i}}<\sum^{\infty}_{i=0}\dfrac{n}{2^i}=2n$
+
+Abbiamo tolto il floor ponendo la serie senza floor maggiore o uguale a quella con il floor, e sostituito k-1 con $\infty$ per maggiorare.
+Otteniamo $T(n)<2n \implies \dfrac{T(n)}{n}<\dfrac{2\cancel{ n }}{\cancel{ n }}=2$
+
 
 ## Contatore Binario con [[Metodo degli Accantonamenti|Accantonamenti]]
 
+Poniamo:
+
+$\hat{c}_{\text{set}}=2$ <br>
+$\hat{c}_{\text{Reset}}=0$ <br>
+
+Un'operazione di $\text{Increment}$ altro non è che $\text{Set}+\text{Reset}$, per cui: \ 
+
+$\hat{c}_{\text{increment}}\leq 2$ \ 
+
+$\displaystyle\sum^n_{i=i}\hat{c}_{i}-\sum^n_{i=1}c_{i}=\text{\#bit sul contatore uguali ad } 1 \geq 0$ , La differenza è non negativa per ogni istante di esecuzione. \ 
+
+Per cui vale: $\displaystyle\sum^n_{i=i}\hat{c}_{i}\geq\sum^n_{i=1}c_{i}$ , e riotteniamo lo stesso risultato del metodo dell'aggregazione: $2n\geq\displaystyle\sum^n_{i=i}\hat{c}_{i}\geq\sum^n_{i=1}c_{i}$ \ 
+
+Ossia $n$ incrementi in tempo $2n$, indipendentemente da $k$  (il numero di bit)
+
+
+
+
 ## Contatore Binario con [[Metodo del Potenziale|Potenziale]]

content/Metodo degli Accantonamenti.md

@@ -5,6 +5,9 @@ tags:
 ---
 # Metodo degli Accantonamenti
 
+Nel metodo degli accantonamenti assegnamo costi variabili a operazioni differenti: cioè qualche operazione potrebbe avere costo maggiore o minore del suo effettivo costo reale. Quando il costo assegnato di un'operazione supera il costo effettivo, la differenza viene assegnata a specifici oggetti della struttura dati sotto forma di _credito_. (concetto logico, assolutamente virtuale). <br>
+Questo credito, sempre **non negativo**, viene depositato o prelevato a seconda delle esigenze.
+In questo caso, le operazioni hanno costo variabile (e quindi non è lo stesso per tutte le operazioni), per cui, la scelta dei costi ammortizzati è di fondamentale importanza. <br>
 Siano $op_{1},op_{2},\dots,op_{n}$ le nostre operazioni, e <br>
 $c_{i}=_{def}\text{costo-reale}(op_{i})$ <br>
 $\hat{c}_{i}=_{def}\text{costo-ammortizzato}(op_{i}) \qquad$ <ins>Definito da noi</ins>.
@@ -16,6 +19,8 @@ $T(n) = \displaystyle\sum^n_{i=1}c_{i}\leq \sum^n_{i=1}\hat{c}_{i}$
 Se $\hat{c}_{i}>c_{i}, \text{ allora } c_{i}$ unità di costo sono utilizzate per pagare il costo della i-esima operazione $op_{i}$. <br>
 Se $\hat{c}_{i}<c_{i},$ la differenza $c_{i}-\hat{c}_{i}$ viene recuperata da crediti immagazzinati nella struttura dati.
 
+In altre parole: paghiamo prima delle operazioni future. Quando il costo reale supera il costo ammortizzato, usiamo il credito per pagare.
+
 A questo punto, viene raggiunto l'obiettivo prefissato pocanzi.
 
 Esempi:

content/Metodo dell'Aggregazione.md

@@ -5,6 +5,7 @@ tags:
 draft: false
 ---
 Consiste nello stimare il costo $\mathbf{T}(n)$ di $n$ operazioni e di equidistribuire tale costo tra le $n$ operazioni $\left( \dfrac{\mathbf{T}(n)}{n} \right)$
+Tutte le operazioni hanno lo stesso costo ammortizzato.
 Esempi:
 - [[Stack Multipop#Multipop con Metodo dell'Aggregazione Aggregazione|Stack Multipop]]
 - [[Contatore binario#Contatore Binario con Metodo dell'Aggregazione Aggregazione|Contatore Binario]]

content/Stack Multipop.md

@@ -27,9 +27,11 @@ Analisi di una sequenza di $n$ operazioni su uno stack <ins>inizialmente vuoto</
 - Costo di $n$ operazioni $=n \mathbf{O}(n) = \mathbf{O}(\color{red}{n^{2}}\color{white})$
 Questa è una sovrastimazione del costo effettivo che potremmo ottenere.
 
+>[!warning] Lo Stack è inizialmente vuoto a meno che non venga specificato altrimenti
+
 ## Multipop con [[Metodo dell'Aggregazione|Aggregazione]]
 
-Lo stack è inizialmente vuoto. Le operazioni di Pop e Push sono elementari, mentre MultiPop(S,k) è un'operazione composta (da più pop).
+Le operazioni di Pop e Push sono elementari, mentre MultiPop(S,k) è un'operazione composta (da più pop).
 Sia $op_{i}$ una qualsiasi operazione (pop, push, multipop):
 
 $\underbrace{ op_{1},op_{2},op_{3},\dots,op_{n-1},op_{n} }_{ \downarrow }$ $\quad \longleftarrow \quad${Pop, Push, Multipop}
@@ -73,8 +75,22 @@ $$\large
 \end{align}
 $$
 
+>[!example]- Esempio di sequenza peggiore
+>$(n-1)Push + (n-1)MultiPop$
+
 ## Multipop con [[Metodo degli Accantonamenti|Accantonamenti]]
 
-todo: this evening (test per commit con messaggio)
+Assegneremo un costo più alto all'operazione di $\text{Push}$.
+Poniamo: <br>
+$\hat{c}_{\text{push}}=2$ (1 unità per il costo reale, + 1 unità per il costo ammortizzato da noi assegnato); <br>
+$\hat{c}_{\text{pop}}=\hat{c}_{\text{multipop}}=0$ <br>
+In ogni istante avremo: $\displaystyle\sum^n_{i=1}\hat{c}^i-\displaystyle\sum^n_{i=1}c_{i}=|S|\geq 0$ dove |S| è il numero di elementi nello stack. <br>
+e quindi: $\displaystyle\sum^n_{i=1}\hat{c}^i\geq \sum^n_{i=1}c_{i}$
+Avendo assegnato 2 al costo ammortizzato dell'operazione $\text{Push}$, avremo:
+
+$\displaystyle\sum^n_{i=1}\hat{c}^i\geq \sum^n_{i=1}c_{i} = 2\times \text{\#Push}\leq 2n$
+
+>[!example]- Controesempio:
+>Se avessimo assegnato costi ammortizzati inversi, una sequenza di sole push senza mai eseguire pop avrebbe generato credito negativo.
 
 ## Multipop con [[Metodo del Potenziale|Potenziale]]