Projektowanie i analiza algorytmów
Design and analysis of computer algorithms
Analiza i projektowanie algorytmów
Analiza algorytmów pozwala odpowiedzieć na pytania:
Czy dany problem może być rozwiązany na komputerze w dostępnym czasie i
określonej pamięci ?
Który algorytm zastosować w danych okolicznościach ?
Czy istnieje lepszy algorytm (czy jest on optymalny) ?
Jak uzasadnić, że dany algorytm rozwiązuje postawione zadanie ?
ASD LJ S
1
Analiza algorytmów
Aspekty analizy algorytmów:
Poprawności semantycznej algorytmu.
Złożoności obliczeniowej: czasowej, pamięciowej.
Określanie poprawności algorytmu:
1. Metoda empiryczna (testowanie programu).
2. Formalne dowodzenie poprawności algorytmu.
Analiza w aspekcie złożoności obliczeniowej (czasowej i przestrzennej) związana
jest z tzw. kosztem algorytmu. Projektowanie algorytmu polega na minimalizacji
tego kosztu.
Analiza algorytmów uwzględnia: poprawność semantyczną, czas działania, zajętość
pamięci, optymalność, okoliczności użycia algorytmu.
ASD LJ S
Metody projektowania algorytmów
Metody projektowania algorytmów:
Meoda  dziel i zwyciężaj (divide-and-conquer strategy).
Programowanie dynamiczne (dynamic programming).
Rekurencja (recursive approach).
Metoda przyrostowa (algorytmy konstrukcyjne) (constructive method).
Metoda zachłanna (greedy approach).
Metody aproksymacyjne (aproximation algorithms).
Metody zrównoleglenia algorytmów (parallel algorithms).
ASD LJ S
2
Metoda  dziel i zwyciężaj
Charakterystyka metody:
Podział problemu wyjściowego na mniejsze podproblemy tej samej postaci
ale mniejszego rozmiaru,
Rozwiązanie podproblemów, na podstawie których wyznaczane jest
rozwiązania końcowe,
Stosowana w połączeniu z rekurencją,
Przykład podejścia zstępującego w projektowaniu (top down),
Rozwiązywane przykładowe problemy: sortowanie  quicksort , sortowanie
 przez scalanie , silnia, przeszukiwanie ciągu itd.
ASD LJ S
Metoda programowania dynamicznego
Charakterystyka metody:
Rozszerzenie i optymalizacja strategii  dziel i zwyciężaj ,
Podział problemu na mniejsze podproblemy (w tym kontekście metoda jest
podobna do metody  dziel i zwyciężaj ), które są najpierw rozwiązywane a
wyniki przechowywane (np. w tablicy),
Wykorzystanie przechowywanych rozwiązań podproblemów do
konstruowania rozwiązania końcowego,
Przykład podejścia wstępującego w projektowaniu (bottom-up),
Rozwiązywane problemy: ciąg fibonacciego, dwumian Newtona, zagadnienia
najkrótszej drogi w gafie, itd.
ASD LJ S
3
Złożoność obliczeniowa algorytmów
Computational Complexity
Hartmanis J., Stearns R.  On the Computational
Complexity of Algorithms , 1965)
Złożoność obliczeniowa
Zakładamy, że rozpatrywane algorytmy realizowane są na maszynie RAM (Random
Access Machine) - koncepcja maszyny Neumanna (Stored program concept).
Cechy maszyny RAM:
1. Rozkazy wykonywane są sekwencyjnie (pobierz-dekoduj-wykonaj rozkaz).
2. Zbiór rozkazów zawiera rozkazy przesłań, arytmetyczne, logiczne,
porównania.
Cele analizy czasowej algorytmu:
1. Porównanie różnych algorytmów rozwiązujących te same problemy.
2. Przewidywanie wydajności algorytmów w nowym środowisku obliczeniowym.
3. Określenie czasowych wartości parametrów algorytmów.
Miara porównania algorytmów powinna być niezależna od: komputera, języka
programowania, systemu operacyjnego, umiejętności programisty, szczegółów
implementacji.
ASD LJ S
4
Złożoność obliczeniowa
Podstawowe rodzaje złożoności.
Złożoność czasowa (time complexity, running time):
- czasu wykonania wyrażony w standardowych jednostkach czasu lub
liczbie cykli procesora (niemożliwe na etapie algorytmu i pseudokodu),
- czasu wykonania wyrażany w ilościach tzw. operacji dominujących
(upraszcza analizę).
Złożoność pamięciową (space complexity):
- zapotrzebowanie na pamięć mierzone w: B, kB, MB, GB, TB,
- ilość użytych zmiennych typów prostych np. integer lub real.
Czasowa złożoność obliczeniowa - funkcja określająca czas potrzebny do
wykonania algorytmu dla konkretnych danych.
Złożoność pamięciowa - funkcja określająca liczbę komórek pamięci potrzebnych
do wykonania algorytmu dla konkretnych danych.
ASD LJ S
Operacje podstawowe
Typowe operacje elementarne (podstawowe, basic operations):
Operacje arytmetyczne, logiczne, relacyjne,
Podstawienie,
Indeksowanie, odwołanie do pola struktury,
Inicjalizacja wywołania funkcji,
Przekazywanie wartości do funkcji,
Operacje we/wy,
 Wizyta w węz
le, przejście po krawędzi (algorytmy grafowe).
Przykłady operacji, które nie są elementarnymi to instrukcje: WHILE, REPEAT, FOR.
ASD LJ S
5
Rozmiar danych wejściowych
Instancja problemu (problem instant) - zestaw danych wejściowych.
Instancje problemu rozróżnia się ze względu na: rozmiar egzemplarza danych
(najczęściej liczbę danych określonych typów) oraz inne właściwości (np.
początkowe uporządkowanie elementów).
Rozmiar danych wejściowych (input size, size of the input) - liczba pojedynczych danych
wchodzących w skład struktury danych. Liczbę tą najczęściej oznaczmy przez n (w
niektórych przypadkach wymaga doprecyzowania).
Określając bardziej formalnie, rozmiar danych wejściowych wyrażanych liczbą n jest
to liczba bitów potrzebnych do jej reprezentowania w kodzie NBC (Natural Binary
Code) naturalnym kodzie binarnym.
Dla wartości n, liczba litów wynosi �łlgn�ł+1, n=100, 1100100, �łlg100�ł+1 7 bitów.
�łx�ł  podłogą liczby rzeczywistej x"R nazywamy największą liczbę całkowitą nie
większą niż x.
ASD LJ S
Rozmiar danych wejściowych
Rozmiar danych wejściowych (przykłady).
1. W problemie sortowania ciągu skończonego a1 a2, ... , an rozmiarem danych
jest liczba n.
2. W przypadku przetwarzania n-wierszowej i m-kolumnowej tablicy rozmiarem
danych jest liczba n* m.
3. Dla algorytmów grafowych do okreslenia rozmiaru danych wejściowych
można użyć liczby wierzcholków i liczby łuków, występujacych w tym grafie.
4. W algorytmie wyznaczania n-tego wyrazu ciągu Fibonacciego n będzie
rozmiarem danych i jednocześnie daną wejściową.
ASD LJ S
6
Złożoność obliczeniowa
Wyznaczanie czasowej złożoności obliczeniowej algorytmu.
Zakładamy, że czas działania algorytmu jest proporcjonalny do liczby wykonań
poszczególnych instrukcji zawartych wewnątrz kolejnych pętli.
Przykład. Wyznaczanie sumy trzecich potęg n najmniejszych liczb całkowitych.
Sum poteg(n) liczba wykonań
{
1. s=0; 1
2. x=1; 1
3. WHILE(xd"n){ (n+1)
4. y=x*x*x; n
5. s=s+y; n
6. x=x+1; n
}
7. return(s); 1
}
Funkcja czasowej złożoności algorytmu T(n) (liczba wykonań poszczególnych
instrukcji): T(n) = 4n + 4
ASD LJ S
Złożoność obliczeniowa
Przykład. Dany jest ciąg n liczb całkowitych. Należy wyznaczyć początek i koniec
fragmentu podciągu, dla którego suma elementów jest największa.
Max pciag V1(A,n,p,k)
//A-tablica indeksowana od 1 do n liczba wykonań
{
maxsum=MinInt; 1
p=1; 1
k=1; 1
FOR(i=1,2,& ,n) n
FOR(j=i,i+1,& ,n){ (n-i+1)
asum=0; J(n)
FOR (k=i,i+1,& ,j) (j-i+1)
asum=asum+A[k]; K(n)
IF (asum>maxsum){ J(n)
maxsum=asum; J(n)
p=i; J(n)
k=j; J(n)
}
}
return(maxsum,p,k); 1
}
ASD LJ S
7
Złożoność obliczeniowa
Liczba operacji elementarnych w algorytmie Max pciag V1 zależy od:
Rozmiaru danych wejściowych n (liczba iteracji poszczególnych pętli).
Wartości danych (spełnienia warunku: asum > maxsum).
Liczba wykonań instrukcji w pętli po k:
j
n n n n n
(n-i +1)(n-i +2) 1 1 1
K(n) = = n3 + n2 + n
" " "1=" "( j -i +1) ="
2 6 2 3
i=1 j=i k=i i=1 j=i i=1
Liczba wykonań instrukcji w pętli po j:
n n n
J(n) = = - i +1) = = n2 + n
" "1 "(n n(n +1) 1 1
2 2 2
i=1 j=i i=1
Złożoność pesymistyczna:
1 17
T(n) =3+5J(n)+ K(n)+1= n3 +3n2 + n +4
6 6
ASD LJ S
Złożoność obliczeniowa
Max pciag V2(A,n,p,k)
//A-tablica indeksowana od 1 do n liczba wykonań
{
maxsum=MinInt; 1
p=1; 1
k=1; 1
FOR(i=1,2,& ,n){ n
asum=0; I(n)
FOR (k=i,i+1,& ,n) { (n-i+1)
asum=asum+A[j]; J(n)
IF (asum>maxsum){ J(n)
maxsum=asum; J(n)
p=i; J(n)
k=j; J(n)
}
}
}
return(maxsum,p,k; 1
}
ASD LJ S
8
Złożoność obliczeniowa
Liczba wykonań instrukcji w pętli wewnętrznej:
n n n
n(n + 1) 1 1
2
J (n) = = i = = n + n
" "1 "
2 2 2
i =1 j =i i=1
J(n)  liczba obrotów pętli po j.
I(n)  liczba obrotów pętli po i.
I(n) = n
Złożoność pesymistyczna:
5 7
2
T (n) = 3 + I (n) + 5J (n) + 1 = n + n + 4
2 2
ASD LJ S
Złożoność obliczeniowa
Max pciag V3(A,n,p,k)
//A-tablica indeksowana od 1 do n liczba wykonań
{
maxsum=MinInt; 1
p=1; 1
k=1; 1
J(n)  liczba obrotów
i=1; 1
pętli po j.
asum=0; 1
FOR(j=1,2,& ,n){ n
asum=asum+A[j]; J(n)
J(n) = n
IF (asum>maxsum){ J(n)
maxsum=asum; J(n)
T(n) =8n+6
p=i; J(n)
k=j; J(n)
}
IF (asum < 0){ J(n)
i=j+1; J(n)
asum=0; J(n)
}
}
return(maxsum,p,k; 1
}
ASD LJ S
9
Złożoność obliczeniowa
Porownanie czasów wykonania algorytmów
Złożoność czasowa (liczba elementarnych operacji)
Rozmiar Algorytm Algorytm Algorytm
problemu n Max pciag V1 Max pciag V2 Max pciag V3
10 500 300 100
102 200 103 25 103 103
103 2 108 2.5 106 8 103
104 1.5 1011 2.5 108 8 104
105 1.5 1014 2.5 109 8 105
ASD LJ S
Złożoność obliczeniowa
Porownanie czasów wykonania algorytmów
Złożoność czasowa (w jednostkach czasowych)
Rozmiar problemu Algorytm Algorytm Algorytm
n Max pciag V1 Max pciag V2 Max pciag V3
10 0.5 ms 0.3 ms 0.1 ms
102 0.2 s 25 ms 1 ms
103 200 s 2.5 s 8 ms
104 45 godz. 5 min 0.8 ms
105 4.5 lat 50 min 0.8 s
Założony czas wykonywania elementarnej operacji wynosi 10-6 s.
Konwersja sekund
102 s 2 min 106 s 1,5 tyg. 109 s 30 lat
104 s 3 godz. 108 s 3 lata 1010 s 300 lat
ASD LJ S
10
Złożoność obliczeniowa
Porownanie czasów wykonania algorytmów
Złożoność czasowa (liczba elementarnych operacji)
Rozmiar problemu Algorytm Algorytm Algorytm
n Max pciag V1 Max pciag V2 Max pciag V3
10 0.5 �s 0.3 �s 0.1 �s
102 0.2 ms 0.025 ms 0.001 ms
103 0.2 s 2.5 ms 0.008 ms
104 3 min 0.25 s 0.08 ms
105 45 godz 2.5 s 0.8 ms
Założony czas wykonywania elementarnej operacji wynosi 10-9 s.
ASD LJ S
Złożoność obliczeniowa
Porownanie czasów wykonania algorytmów
Złożoność czasowa (liczba elementarnych operacji)
Rozmiar Algorytm Algorytm Algorytm
problemu n Max pciag V1 Max pciag V2 Max pciag V3
10 0.5 ns 0.3 ns 0.1 ns
102 0.2 �s 25 ns 1 ns
103 0.2 m s 2.5 �s 8 ns
104 0.15 s 0.25 ms 80 ns
105 3 min 2.5 ms 0.8 �s
Założony czas wykonywania elementarnej operacji wynosi 10-12 s.
ASD LJ S
11
Operacje dominujące
O złożoności czasowej algorytmu decydują operacje, które zwykle umieszczone są
w najbardziej wewnętrznej pętli.
Operacje takie nazywamy dominującymi (dominant operations).
Liczba operacji dominujących jest:
1. Proporcjonalna do liczby wszystkich operacji algorytmu.
2. Rzędu liczby wszystkich operacji.
3. Proporcjonalna do czasu działania programu implementującego algorytm.
Problem Operacja
Wyszukiwanie elementu x na liście Porównywanie x z pozycją na liście
Mnożenie dwóch macierzy Mnożenie dwóch liczb typu real
Sortowanie liczb Porównywanie dwóch liczb, zamiana liczb
Trawersowanie grafu Operacja na węz
le, krawędzi
ASD LJ S
12
Asymptotyczna złożoność obliczeniowa
Notacje asymtotyczne
(Asymptotic notation, Order notation)
ASD LJ S
Notacje asymtotyczne
Asymptotyczne ograniczenie górne (asymptotic upper bound).
O-notacja.
Funkcja f(n) jest co najwyżej rzędu g(n) ( f(n)=O(g(n)) ) jeżeli:
(" c>0 ) (" n0 e" 0 ) " n e" n0 zachodzi f(n)d" c g(n).
f(n) =O(g(n)) gdy lim f(n)/g(n) = 0.
n"
g(n) `" O(f(n)).
Inna definicja O-notacji:
f(n) =O(g(n)) a" lim n" sup ćłf(n)/g(n) ćł< "
Paul Bachman (1892)
ASD LJ S
13
Notacje asymtotyczne
Symbol O(g(n)) oznacza zbiór funkcji f: NR+ zdefiniowany następująco:
O( g(n) ) = {f" R+: istnieje taka stała c>0 i n0"N, że f(n)d"c g(n) dla
każdego n > n0 }
Równoważne zapisy: f(n)=O(g(n)), f"O(g(n)).
Sens notacji O polega na istnieniu  asymptotycznego ograniczenia górnego ,
pozwalającego oszacować od góry wartości funkcji f przez wartości funkcji g.
ASD LJ S
Notacje asymtotyczne
1. f(n) = n2/2 = O(n3)
n2 / 2 = 1 = 0
lim lim
n" n"
2n
n3
2. f(n) = nlogn = O(n2)
logba = logca / logcb
nlogn lnn 1/ n
= = = 0
lim lim lim
n" n" n"
nln2 ln2
n2
Wniosek:
nlogn = O(n2) ale n2 `" O(nlogn)
ASD LJ S
14
O  notacja
3. f(n) = n
n d" 1 n2 dla n e" 1
f(n) = O(n2)
4. f(n) = n2+5n
n2+5n d" 2n2 dla n e" n0= 5, stąd c=2 oraz n0 = 5
n2+5n = O(n2)
dla c=6 oraz n0 = 1 zachodzi: n2+5n d" n2+5n2 = 6 n2
5. f(n) = n2
n2 = O(n2 + 5n)
n2 d" 1 (n2+5n) dla c=1 oraz n0=0
ASD LJ S
O  notacja
6. f(n) = 2n2 + 15n + 5lg n + 50
f(n) = 2n2 + 15n + O(lg n)
f(n) = 2n2 + O(n)
f(n) = O(n2)
7. f(n) = 2n2 + 3n + 1 = O(n2)
Wartości c, n0 otrzymujemy, rozwiązując nierówność:
2n2 + 3n + 1 d" cn2
c e" 6 e" 3,8 e" 3,2 e" 2,9 e" 2,7 2
n0 1 2 3 4 5 "
ASD LJ S
15
O  notacja
Funkcje T(n) czasowej złożoności określonego algorytmu.
1 11 7
3 2
1. T(n) = + + n + 4
n n
2 2 2
Dla n > 12 zachodzi:
1
3 3
< T (n) <
n n
2
T(n)=O(n3)
n(n-1)
2.
T(n) =
2
Dla n>0 zachodzi:
2
n ( n - 1) n (n )
n
d" =
2 2 2
T(n)=O(n2)
ASD LJ S
O  notacja
2
1. T (n) = + 10 n
n
Dla n e" 10 zachodzi:
2 2
T (n) = + 10n d" 2
n n
Możemy przyjąć c=2 oraz n0=10, w celu stwierdzenia, że T(n)=O(n2).
ASD LJ S
16
O  notacja
Dla małych n algorytm2 o większej asymptotycznej złożoności obliczeniowej może
okazać się lepszy. Algorytm lepszy asymptotycznie nie zawsze jest lepszy dla
małych n.
Algorytm2
Algorytm1
ASD LJ S
Kategorie złożoności
Kategorie złożoności (complexity categories) są to zbiory funkcji, które mają takie
samo asymptotyczne ograniczenie.
Określenie formalne Określenie werbalne
O(1) stała
O(n) liniowa
O(nr) 0O(lg n) logarytmiczna
O(n lg n) liniowo - logarytmiczna
O(n2) kwadratowa
O(nr) 1O(nk) ke"1 wielomianowa
O(rn) r>1 wykładnicza
ASD LJ S
17
Typowe funkcje złożoności
T(n) = O(1): czas realizacji algorytmu jest stały, Większość instrukcji wykonuje
się raz lub kilka razy.
T(n) = O(n): algorytm działa w czasie liniowym (linear time), na każdy z n
elementów wejściowych potrzebna jest niewielka ilość czasu przetwarzania.
T(n) = O(lgn): algorytm nieznacznie spowalnia ze wzrostem n. Taka zależność
występuje w przypadkach, kiedy rozwiązywanie polega na transformacji
wyjściowego zadania na szereg cząstkowych zadań, transformacji redukującej
rozmiar zadania wyjściowego (np. przeszukiwanie binarne).
ASD LJ S
Typowe funkcje złożoności
T(n) = O(nlgn): Przypadek w którym problem jest rozwiązywany poprzez
rozbicie go na niezależne podproblemy o mniejszym rozmiarze, a następnie
połączenie otrzymanych rozwiązań (np. sortowanie przez scalanie).
T(n) = O(nk): Algorytm nadaje się do rozwiązywania relatywnie niedużych
zadań. Przypadek dotyczy z reguły przetwarzania wszystkich par n elementów
wejściowych (np. przetwarzanie dwuwymiarowych tablic).
T(n) = O(2n): Algorytmy w niektórych przypadkach są akceptowane w
rozwiązaniach praktycznych. Kiedy n podwaja się czas rośnie do kwadratu (np.
wyznaczanie wszystkich podzbiorów zbioru).
ASD LJ S
18
Typowe funkcje złożoności
Wartości najczęściej spotykanych funkcji złożoności.
n lg nlgn n2
10 3 33 100
100 7 664 10000
1000 10 9966 1000000
10000 13 132877 100000000
ASD LJ S
Typowe funkcje złożoności
Kategorie złożoności (complexity categories).
ASD LJ S
19
Złożoność asymtotyczna
A1 //Ciąg instrukcji A2 //Pojedyncza pętla
{ {
s1; s2; ...; sn; For i=1,2,..., n
} s;
}
O(1)
nO(1) = O(n).
A3 //Podwójna pętla
A4 //Podwójna pętla,zale\
ność indeksów
{
{
For i:=1,2,...,n
For i:=1,2,..., n
For j:=1,2,...,n
For j:=1,2,..., i
s;
s;
}
}
n
n(n +1) 2
O( = O( ) = O( )
"i) 2 n
1
O(n2)
ASD LJ S
Własności notacji
Własności  O notacji:
Mnożenie przez stałą:
k f(n) = O(f(n))
k O(f(n)) = O(f(n))
O(k f(n)) = O(f(n))
Suma:
O(f1(n))+ ...+ O(fk(n)) = O(f1(n) + ...+ fk(n))
Iloczyn:
O(f(n)) O(g(n)) = O(f(n) g(n))
Przechodniość:
f(n) = O(g(n)) i g(n) = O(h(n)) �! f(n) = O((h(n))
ASD LJ S
20
Własności notacji
Wielomian wyższego stopnia rośnie szybciej niż wielomian stopnia niższego:
nr =O(ns) jeżeli 0 d" r d" s
Funkcja wykładnicza rośnie szybciej niż funkcja wielomianowa:
nk =O(bn) dla b > 1, k e" 0
Funkcja logarytmiczna rośnie wolniej niż wielomianowa:
logbn =O(nk) dla b > 1, k > 0
Wszystkie logarytmy rosną w tym samym stopniu:
logbn =O(logdn) dla b, d > 1
ASD LJ S
Notacje asymtotyczne
Asymptotyczne ograniczenie dolne (asymptotic lower bound).
&! - notacja.
&!
&!
&!
Funkcja f(n) jest co najmniej rzędu g(n) ( f(n)=&!(g(n)) ) jeżeli:
(" c>0 ) (" n0 e"0 ) " n > n0 zachodzi: f(n) e" c g(n)
f(n) = &! (g(n)), gdy lim f(n)/g(n) = +"
n"
Inna definicja &!-notacji:
f(n) = &!(g(n)) a" lim n" inf ćłf(n)/g(n)ćł> 0
g(n) = O(f(n)).
Notacja &! wymaga istnienia  asymptotycznego ograniczenia dolnego ,
pozwalającego oszacować  od dołu funkcję f przez funkcję g.
ASD LJ S
21
&! - notacja
&!
&!
&!
1. f(n) = 5n2
5n2 e" 1�" n2 dla c = 1, n0 = 0, n e" n0
f(n) = &!(n2)
n(n -1)
f (n) =
2.
2
Dla n e" 2 zachodzi (n-1) e" n/2
2
n (n - 1) n n
n
f (n ) = e" �" = n(n -1) n(n)
n2
f (n) = d" =
2 2 2 4
2 2 2
c = 1/4, n0 = 2
c = 1/2, n0 = 0
f(n) = &!(n2).
f(n) = O(n2).
ASD LJ S
Ś - notacja
Ś
Ś
Ś
Ś - notacja.
Funkcja f(n) jest rzędu Ś(g(n)) ( f(n)=Ś(g(n) ) ) jeżeli:
(" c1, c2>0 ) (" n0 e"0 ) " n e" n0 zachodzi: c1g(n)d"f(n)d"c2 g(n)
f(n) = Ś(g(n)), gdy lim f(n)/g(n) = const
n"
Ś(g(n)) = O(g(n)) )" &!(g(n))
O( )
Ś( )
&!( )
Sens notacji Ś polega na istnieniu  asymptotycznego ograniczenia dolnego i górnego ,
pozwalającego oszacować  od dołu i  od góry funkcję f przez funkcję g.
ASD LJ S
22
Ś - notacja
Ś
Ś
Ś
1 11 7
n(n -1)
T(n) = n3 + n2 + n + 4
T (n) =
2 2 2
2
Dla c1 = 1/2, c2 = 1 oraz n0 = 12
Dla c1 = 1/4, c2 = 1/2 oraz n0 = 2
1 1 1
3 3
n2 < T(n) < n2 n < T (n) < n
4 2 2
T(n)= O(n3) )" &!(n3)= Ś(n3)
T(n)= O(n2) )" &!(n2)= Ś(n2)
O &! O( ) &!( )
Ś( )
2n2 2n2
3n2+6 3n2+6
5n+7
2n2 2n+4n
5n2+2n 5n2+2n
4n3+3n2
2nlgn
3n2+6
5n+7 2n+4n
5n2+2n
2nlgn 4n3+3n2
O(n2)
&!(n2) Ś(n2)= O(n2))"&!(n2)
ASD LJ S
Złożoność obliczeniowa
Nierealizowalność algorytmu jest wewnętrzną cechą algorytmów o złożoności
wykładniczej.
Rozmiar danych n 30 50 60
Liczba operacji 2n 0.1 1010 1015 1018
Czas działania 0.1 s 105 s 108 s
(10-10 s/op.) (28h) (3 lata)
Czas działania 0.1 10-3 s 102 s 105 s
(10-13 s/op.) (28h)
Charakteryzowanie w sposób asymptotyczny efektywności algorytmu jest abstrakcją,
w której pomija się szczegóły. Posługiwanie się tą miarą wymaga uświadomienia
sobie szczegółów, które taka abstrakcja ukrywa.
ASD LJ S
23
Rodzaje złożoności obliczeniowej
Złożoność pesymistyczna (worst-case complexity),
Złożoność oczekiwana (average-case complexity),
Złożoność optymistyczna (best-case complexity).
ASD LJ S
Rodzaje złożoności obliczeniowej
Oznaczenia.
Dn - zbiór możliwych zestawów danych (instancji) o rozmiarze n
I - zestaw danych, element zbioru Dn (I " Dn)
t(I) - liczba operacji podstawowych dla zestawu danych wejściowych I"Dn
Xn - zmienna losowa, której wartością jest t(I) dla I"Dn
pn,k  prawdopodobieństwo tego, że dla zestawu danych I wykonano k
operacji dominujących, pn,k=Pn(Xn=k)
Pn - rozkład prawdopodobieństwa ( z reguły równomierny) zmiennej losowej Xn.
ASD LJ S
24
Rodzaje złożoności obliczeniowej
Złożoność pesymistyczna (worst case running time)
Tworst(n) = sup { t(I): I"Dn}
Złożoność oczekiwana (average case running time) (wartość oczekiwana
zmiennej losowej Xn)
Tave(n) = E(Xn) = k pn,k
Ł
ke"0
Złożoność optymistyczna (worst case running time)
Tbest(n) = inf { t(I): I"Dn }
ASD LJ S
Wrażliwość obliczeniowa algorytmu
Wrażliwość pesymistyczna (worst- case sensitivity):
" (n) = Tworst(n)  Tbest(n) = sup { t(I1) - t(I2): I1, I2"Dn }
wcs
Wrażliwość oczekiwana (average- case sensitivity):
�acs(n) = dev(Xn) = " Var(Xn)
gdzie: dev(Xn)  standardowe odchylenie zmiennej losowej Xn,
var(Xn)  wariancja zmiennej losowej Xn,
= (Xn)
)2 pn,k
var( ) ((k - E
Xn
"
ke"0
ASD LJ S
25