Raspuns: ĉ_i = 3

Explicatie: Incepem cu un array cu capacitate 1 si 0 elemente (vom nota cost insert = c_i, copiere n elemente = cpy_n.

• insert1: c = c_i = 1
• insert2: c = cpy₁ + c_i = 2
• insert3: c = cpy₂ + c_i = 3
• insert4: c = c_i = 1
• insert5: c = cpy₄ + c_i = 5
• insert6: c = c_i = 1
• insert7: c = c_i = 1
• insert8: c = c_i = 1
• insert9: c = cpy₈ + c_i = 9

Observam ca numarul de copieri este cpy₁ + cpy₂ + cpy₄ + cpy₈ + … + cpy_n = 2 * n (suma geometrica). (1)

De asemenea, au avut loc n insert-uri, care au c = n. (2)

Din (1) si (2) ⇒ ĉ_i = T(n) / n = (2 * n + n) / n = 3.

Raspuns = ĉ_i = 2.

Presupunem cel mai rau caz: capacitate = 4 * n, nr. elemente = n + 1 (delete va cauza o copiere, deoarece la primul delete ajungem la 1/4 din capacitate)

• delete1: cpy_n/2 + c_delete = n/2 + 1 → capacitatea devine 2 * n
• delete2: c_delete = 1
• delete3: c_delete = 1
• …
• delete(n/2): cpy_n/4 + c_delete = n/4 + 1 → capacitatea devine n

Observam ca numarul de copieri este cpy_n/2 + cpy_n/4 + cpy_n/8 + … = n. (1)

Numarul de stergeri efective este n. (2)

Din (1) si (2) ⇒ ĉ_i = T(n) / n = (n + n) / n = 2.

Fie capacitatea initiala = 1, c_i = costul inserarii, c_d = costul stergerii.

Stim ca:

• c_i = 1 pentru cazul fara copiere
• c_i + m cazul pentru copiere si inserare
• c_d = 1 pentru cazul fara copiere
• c_d + m pentru cazul stergerii si copierii
• n_final = k - p numarul final de elemente (elemente inserare - elemente sterse)
• nr_operatii = k + p

⇒ ĉ_i = C_total / (k + p) = (C_ins + C_del) / (k + p)

Am stabilit precedent ca:

• costul tuturor copierilor la inserare este de 2k
• costul tuturor inserarilor efective este k
• ⇒ C_ins = 3k

De asemenea:

• costul tuturor copierilor la stergere este de p
• costul tuturor stergerilor efective este tot p
• ⇒ C_del = 2p

⇒ ĉ_i = (3k + 2p) / (k + p)

Interpretare:

• pentru p = 0, avem ĉ_i = 3 (adevarat, asta este costul doar inserarilor)
• pentru k = 0 (presupunem ca avem deja un array), ĉ_i = 2 (adevarat, costul stergerii)
• pentru k = p, avem ĉ_i = 2.5
• ⇒ costul amortizat este mai apropiat de 3 pentru mai multe inserari, dar mai apropiat de 2 pentru mai multe stergeri.

(pentru insertion: 3 bani → 1 inserare, 1 banut atribuit inseratiei curente, 1 banut atribuit altei inseratii din bucata copiata precedent)

Idee de rezolvare: impartim array-ul in 2 bucati, bucata care se va copia la resize iar bucata care se va sterge fara impact. Cand facem o stergere, avem cost 1 pentru stergerea efectiva, dar atribuim un banut unui element (care nu se va sterge) pentru copierea sa ulterioara. Astfel, la timpul unui resize, vom avea banutii exacti necesari pentru copiere.

ĉ_i = c_i + Φ(D_i) - Φ(D_i-1).

Definim n = elemente curente, m = capacitate:

Fie

  Φ(n,m) = 2n - m,  daca n >= m/2
         = m/2 - n, altfel

1. Cazul stergerii in cazul in care capacitatea nu se schimba:

• c_i = 1
• ΔΦ = Φ(n - 1, m) - Φ(n, m):
  • caz 1, n >= 2m: ΔΦ = 2n - 2 - m - 2n + m = -2 ⇒ ĉ_i = -1
  • caz 2, n < m: ΔΦ = m/2 - n - (m/2 - n - 1) = 1 ⇒ ĉ_i = 2

Aflam ca pentru un load factor de peste 1/2 (suntem aproape de capacitatea maxima) avem cost amortizat -1, iar 2 daca ne apropiem de injumatatire.

2. Cazul stergerii in care capacitatea se schimba:

• Perechea (n, m) este de fapt (n + 1, 4 * n) → (n, 2 * n)
• ΔΦ = Φ(n, 2 * n) - Φ(n + 1, 4 * n) = (2 * n - 2 * n) - (4 * n / 2 - n - 1) = 1 - n
• c_i = 1 + n (deletion + copiere)
• ĉ_i = 1 + n + (1 - n) = 2