From ff4c24480dae06f6902b8de55c077547a591a33e Mon Sep 17 00:00:00 2001 From: Darakuu Date: Fri, 15 Dec 2023 14:12:40 +0100 Subject: [PATCH] piccoli edit ad analisi ammortizzata e aggregazione, aggiunge metodo accantonamenti --- content/Analisi Ammortizzata.md | 1 + content/Contatore binario.md | 42 ++++++++++++++++++++------ content/Metodo degli Accantonamenti.md | 5 +++ content/Metodo dell'Aggregazione.md | 1 + content/Stack Multipop.md | 20 ++++++++++-- 5 files changed, 58 insertions(+), 11 deletions(-) diff --git a/content/Analisi Ammortizzata.md b/content/Analisi Ammortizzata.md index bb81272..073d274 100644 --- a/content/Analisi Ammortizzata.md +++ b/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]] diff --git a/content/Contatore binario.md b/content/Contatore binario.md index 81b0bd0..575e394 100644 --- a/content/Contatore binario.md +++ b/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$
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=$
+Otteniamo una serie geometrica di ragione $\dfrac{1}{2}$
+$= \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$
+$\hat{c}_{\text{Reset}}=0$
+ +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]] \ No newline at end of file diff --git a/content/Metodo degli Accantonamenti.md b/content/Metodo degli Accantonamenti.md index 3587a4e..8ddab7e 100644 --- a/content/Metodo degli Accantonamenti.md +++ b/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).
+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.
Siano $op_{1},op_{2},\dots,op_{n}$ le nostre operazioni, e
$c_{i}=_{def}\text{costo-reale}(op_{i})$
$\hat{c}_{i}=_{def}\text{costo-ammortizzato}(op_{i}) \qquad$ Definito da noi. @@ -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}$.
Se $\hat{c}_{i}inizialmente vuoto[!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:
+$\hat{c}_{\text{push}}=2$ (1 unità per il costo reale, + 1 unità per il costo ammortizzato da noi assegnato);
+$\hat{c}_{\text{pop}}=\hat{c}_{\text{multipop}}=0$
+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.
+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]] \ No newline at end of file