Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
aa:lab:sol:11 [2024/01/06 11:46]
alexandra.udrescu01
aa:lab:sol:11 [2024/01/08 23:55] (current)
stefan.sterea
Line 29: Line 29:
  
 Alegem: \\ Alegem: \\
- $ \hat(c_{push}= 2 $  \\ + $ \hat c_{push} = 2 $  \\ 
- $ \hat(c_{pop}= 0 $  \\ + $ \hat c_{pop} = 0 $  \\ 
- $ \hat(c_{mpop}= 0 $ + $ \hat c_{mpop} = 0 $ 
  
 Aratam ca:  $ cost(S) \leq \sum_{i=1}^{n}\hat{c_i} $ . \\ Aratam ca:  $ cost(S) \leq \sum_{i=1}^{n}\hat{c_i} $ . \\
Line 42: Line 42:
 Definim o functie ne-negativa de potential ​ $ \Phi : States -> ℕ $  Definim o functie ne-negativa de potential ​ $ \Phi : States -> ℕ $ 
  
-Notand costurile amortizate ale unei operatii arbitrare cu  $ \hat(c_{i}$  si costul sau real cu  $ c_i $ , avem de aratat ca: \\+Notand costurile amortizate ale unei operatii arbitrare cu  $ \hat c_{i} $  si costul sau real cu  $ c_i $ , avem de aratat ca: \\
  $ \sum_{i=1}^{n}{c_i} \leq \sum_{i=1}^{n}{\hat{c_i}} $   $ \sum_{i=1}^{n}{c_i} \leq \sum_{i=1}^{n}{\hat{c_i}} $ 
  
Line 57: Line 57:
  
 Calculam costul amortizat al fiecarei operatii:\\ Calculam costul amortizat al fiecarei operatii:\\
- $ \hat(c_{push}= c_{push} + \Phi(D_i) - \Phi(D_{i-1}) = c_{push} + (m + 1) - m = c_{push} + 1 = 1 + 1 = 2 $ \\ + $ \hat c_{push} = c_{push} + \Phi(D_i) - \Phi(D_{i-1}) = c_{push} + (m + 1) - m = c_{push} + 1 = 1 + 1 = 2 $ \\ 
- $ \hat(c_{pop}= c_{pop} + \Phi(D_i) - \Phi(D_{i-1}) = c_{pop} + (m - 1) - m = c_{pop} - 1 = 1 - 1 = 0 $  \\ + $ \hat c_{pop} = c_{pop} + \Phi(D_i) - \Phi(D_{i-1}) = c_{pop} + (m - 1) - m = c_{pop} - 1 = 1 - 1 = 0 $  \\ 
- $ \hat(c_{mpop(k)}= c_{mpop(k)} + \Phi(D_i) - \Phi(D_{i-1}) = c_{mpop(k)} + (m - k) - m = c_{mpop(k)} - k = k - k = 0 $ + $ \hat c_{mpop(k)} = c_{mpop(k)} + \Phi(D_i) - \Phi(D_{i-1}) = c_{mpop(k)} + (m - k) - m = c_{mpop(k)} - k = k - k = 0 $ 
  
 ==== 2. Heap ==== ==== 2. Heap ====
- 
  
 === 2.1. Aggregate Method === === 2.1. Aggregate Method ===
Line 68: Line 67:
 Fie $ S $ o secventa de $ n $ inserari intr-un heap gol. Pentru a Fie $ S $ o secventa de $ n $ inserari intr-un heap gol. Pentru a
 simplifica analiza, dar fara a influenta rezultatul, vom presupune ​ simplifica analiza, dar fara a influenta rezultatul, vom presupune ​
-ca $ n = 2^k $.+ca $ n = 2^k $, $ k = log_2(n) ​$.
  
-Pe nivelul ​$ log(n) $ avem 1 element. +Pe nivelul ​avem 1 nod (radacina) care necesita maxim 0 swap-uri pentru a ajunge pe pozitia corecta\\  
-..+Pe nivelul ​avem 2 noduri care necesita maxim 1 swap-uri pentru a ajunge pe pozitia corecta\\  
-Pe nivelul ​avem n/8 elemente+Pe nivelul 2 avem 4 noduri care necesita maxim 2 swap-uri pentru a ajunge pe pozitia corecta. \\  
-Pe nivelul 2 avem n/elemente+..\\ 
-Pe nivelul ​avem n/elemente.+Pe nivelul ​avem 2^k $ noduri care necesita maxim k swap-uri pentru a ajunge pe pozitia corecta\\ 
  
-Ca un nod sa ajunga de pe ultimul nivel  +Pentru a insera ​un nod in heap, avem nevoie de costul de inserare ​($ $) si costul de pozitionare prin swap cu parintii.
-(aici nivel $ 1 $ pentru a face calculele usoare)  +
-pana la unul din nivelele +
-superioare, avem nevoie de+
-- nivel $ log(n) log(n- 1 $ swaps +
-... +
-- nivel $ 3 $ - $ 2 $ swaps +
-- nivel $ 2 $ - $ 1 $ swaps +
-- nivel $ 1 $ - $ 0 $ swaps+
  
-Deci costul total pentru ​$ n $ inserari e format din costul de creare ​ +cost(S) = \sum_{i=1}^{n}{1} + \sum_{i=1}^{k}{nodes(i) * swaps(i)} = \\ 
-al unui nou nod, $ 1 $ insumat cu numarul de swaps necesare pentru a  += n + \sum_{i=1}^{log_2(n)}{2^i * i} = \\ 
-aduce toate nodurile pe pozitiile actuale este:+https://​www.wolframalpha.com/​input?​i=sum+j%3D0+to+n+of+j+2%5Ej \\ 
 +$ = n + 2(log_2(n) * 2^{log_2(n)} - 2^{log_2(n)} + 1) = $ \\ 
 +$ = n + 2(log_2(n) * n - n + 1) = $ \\ 
 +$ = n + 2 * log_2(n) * n - 2n + 2 = O(nlog(n)) $
  
-$ cost(S) = 1 * n + \sum_{i=1}^{log(n)}{nodes(i) * swaps(i)} = $ \\ +Deci, pentru o singura operatie de insert, avem $ cost(insert) = cost(Sn = O(nlog(n)/ n = O(log(n)) $
-$ = + \sum_{i=1}^{log(n)}{n/(2^i) * (i - 1)} = $ \\ +
-$ \leq + n \sum_{i=1}^{\infty}{(i - 1)/(2^i)} $ \\ +
-$ \leq + n = 2n $ \\ +
-(puteti folosi inductie pentru acea suma sau https://​www.wolframalpha.com/​input?​i=%5Csum_%7Bi%3D1%7D%5E%7Binf%7D%7B%28i+-+1%29%2F%282%5Ei%29%7D+) +
- +
-Deci, costul uni singur insert este:\\ +
-$ cost(op= cost(S) / n = 2 $+
  
 === 2.2. Accounting Method === === 2.2. Accounting Method ===
Line 103: Line 90:
 Pentru fiecare $ insert $, avem nevoie sa luam in considerare:​ Pentru fiecare $ insert $, avem nevoie sa luam in considerare:​
   - costul de creare al unui nou nod = $ 1 $   - costul de creare al unui nou nod = $ 1 $
-  - un potential ​swap cu parintele ​= $ 1 $+  - swap cu parintii ​= $ log(n) $ 
 + 
 +Alegem $ \hat c_{insert} = + log(n) = O(log(n)) ​$
  
-\hat(c_{insert}= 2$+Acest cost este mereu mai mare sau egal decat costul real al unei operatii, dat fiind ca nu toate operatiile au nevoie de log(n) $ swap-uri.
  
 === 2.3. Potential Method === === 2.3. Potential Method ===
Line 115: Line 104:
 $ \Phi(D_i) = $ numarul de valori in heap $ \Phi(D_i) = $ numarul de valori in heap
  
-Calculam costul amortizat ​intr-un caz simplu, cand nodul nu trebuie  +Calculam costul amortizat: \\ 
-interschimbat cu parintele: \\ +$ \hat{c_i} = c_{i} + \Phi(D_i) - \Phi(D_{i-1}) = c_{i} + 1 $
-$ \hat{c_i} = c_{i} + \Phi(D_i) - \Phi(D_{i-1}) = i - (i - 1) = 2 $+
  
-Aratam acum ca acest cost a fost ales corect, demonstrand inegalitatea \\ +c_{i} $ are un cost $ log(n) + 1 $ dat de numarul de swap-uri maxim + inserarea unui nod in heap.
-sum_{i=1}^{n}{c_i} \leq \sum_{i=1}^{n}{\hat{c_i}} ​$+
  
-Am aratat anterior ca $ \sum_{i=1}^{n}{c_i} \leq 2n $ +Deciputem alege $ \hat{c_i} = log(n) + 2 $
-iar \sum_{i=1}^{n}{\hat{c_i}} = 2n $.+
  
  
Line 151: Line 137:
   - o schimbare ulterioara a bitului din 1 in 0   - o schimbare ulterioara a bitului din 1 in 0
  
-$ \hat(c_{increment}= 2$+$ \hat c_{increment} = 2$
  
  
Line 171: Line 157:
  
 Aratam ca $ \sum_{i=1}^{n}{c_i} \leq \sum_{i=1}^{n}{\hat{c_i}} $ \\ Aratam ca $ \sum_{i=1}^{n}{c_i} \leq \sum_{i=1}^{n}{\hat{c_i}} $ \\
-$ \sum_{i=1}^{n}{c_i} = 2n $ (am vazut mai devreme la metoda agregarii) \\ +\hat{c}_i = c_i + \Phi(F_i) - \Phi(F_{i-1}) => \sum_{i=1}^{n}{\hat{c_i}} = \sum_{i=1}^{n}{c_i + \Phi(F_i- \Phi(F_{i-1})} = $ \\ 
-$ \sum_{i=1}^{n}{\hat{c_i}} = n * \hat{c_i= 2n $+\sum_{i=1}^{n}{c_i} + \Phi(F_n) - \Phi(F_{0}) $ 
 + 
 +\Phi(F_n) \geq \Phi(F_{0}) $ se intampla mereu pentru ca numarul de biti de 1 nu poate scadea sub $ 0 $, adica atatia biti $ 1 $ cat sunt in starea $ F_0 $