Analiza kosztu zamortyzowanego

Koszt zamortyzowany operacji - średni koszt pojedynczej operacji w najgorszym przypadku:

jeśli dla każdego n pesymistyczny czas wykonania ciągu n operacji można ograniczyć przez T(n), koszt zamortyzowany pojedynczej operacji wynosi T(n)/n.

Koszt zamortyzowany może okazać się znacznie mniejszy niż pesymistyczny czas działania jednej operacji.

Analiza zamortyzowanego kosztu algorytmów służy do szacowania kosztu algorytmów, w których następują ciągi podobnych operacji.

Operacje na stosiePUSH(S, x) - włożenie elementu x na stos S, O(1)

POP(S) - zdjęcie elementu ze stosu S, O(1)

STACK-EMPTY(S) - daje w wyniku TRUE, jeśli stos jest pusty

MULTIPOP(S, k) - usuwa k elementów ze stosu S lub opróżnia go, jeśli na stosie było mniej niż k elementów; min(s,k)

MULTIPOP (S, k)

1 while not STACK-EMPTY(S) i k 0

2 do POP(S)

3 k := k - 1

Przeanalizujemy ciąg n operacji PUSH, POP i MULTIPOP na początkowo pustym stosie.

Analiza operacji na stosieZwykłe podejście:

Rozmiar stosu nie może przekroczyć n, więc pesymistuczny czas działania operacji MULTIPOP można ograniczyć przez O(n). Wtedy pesymistyczny koszt n operacji jest O(n2).

To oszacowanie górne jest poprawne, ale można uzyskać dokładniejsze.

Analiza kosztu zamortyzowanego:

Każdy obiekt, po włożeniu na stos, może być zdjęty co najwyżej jeden raz. Stąd liczba wywołań POP, włączając w to wywołania wewnątrz operacji MULTIPOP, nie może być większa niż liczba operacji PUSH, która nie jest większa niż n. Dlatego dla dowolnego n łączny czas wykonania każdego ciągu n operacji PUSH, POP i MULTIPOP na początkowo pustym stosie wynosi co najwyżej O(n). Koszt zamortyzowany operacji jest równy O(n)/n = O(1)

Licznik binarny K-bitowy licznik binarny, który może przyjmować nieujemne wartości

całkowite, jest reprezentowany przez tablicę bitów A[0 .. k-1], gdzie length[A] = k.

Wartość Koszt

INCREMENT (A) 0 0 0 0 0

1 i := 0 1 0 0 11 1

2 while i < length[A] i A[i] = 1 2 0 1 01 0 3

3 do A[i] := 0 3 0 1 11 4

4 i := i + 1 4 1 0 01 0 0 7

5 if i < length[A] 5 1 0 11 8

6 then A[i] := 1 6 1 1 01 0 10

7 1 1 11 11

Przeanalizujemy ciąg n operacji INCREMENT na liczniku.

Analiza operacji INCREMENT Zwykłe podejście:

Pojedyncze wykonanie procedury INCREMENT może trwać (k) w pesymistycznym przypadku (kiedy w A są samie jedynki), więc czas działania n takich operacji można ograniczyć przez O(nk).

Analiza kosztu zamortyzowanego:

Nie wszystkie bity są modyfikowane przy każdym wywołaniu procedury. Bit A[0] jest modyfikowany przy każdym wywołaniu procedury INCREMENT; bit A[1] - w co drugim wywołaniu, A[2] - w co czwartym i t.d. Dla i = lgn bit A[i] ulega modyfikacji n/2i razy w ciągu n operacji. Dla i > lgn bit A[i] nigdy nie jest modyfikowany. Liczba modyfikacji bitów wynosi:

n22

1n

2

n

0ii

nlg

0ii

Czas wykonania n operacji - O(n)

Zamortyzowany koszt każdej - O(1)

Powiększanie tablicyTABLE-INSERT(T, x)

1 if size[T] = 0

2 then przydziel 1 komórkę dla table[T]

3 size[T] := 1

4 if num[T] = size[T]

5 then przydziel 2size[T] komórek dla new_table

6 wstaw wszystkie elementy z table[T] do new_table

7 zwolnij table[T]

8 table[T] := new_table

9 size[T] := 2size[T]

10 wstaw x do table[T]

11 num[T] := num[T] + 1

Analiza powiększania tablicy

Niech n operacji TABLE-INSERT wykonuje się na początkowo pustej tablicy.

Koszt i-j operacji wynosi:

n3n2n2ncnlg

0i

jn

1ii

,1

,ici

jeśli i-1 jest całkowitą potęgą 2

w przeciwnym razie

Całkowity koszt n-j operacji wynosi:

Koszt zamortyzowany każdej operacji jest ograniczony przez 3