1. No category

Analys av algoritmer
• Vad kan analyseras?
Datastrukturer och
algoritmer
- Exekveringstid
- Minnesåtgång
- Implementationskomplexitet
Föreläsning 2
Analys av Algoritmer
- Förstålighet
- Korrekthet
-
29
30
Varför analysera algoritmer?
Johan Eliasson
Beräkningsbar/hanterbar
• Exekveringstid/minnesåtgång
Alla (mattematiska)problem
- Är algoritmen praktiskt körbar
Icke hanterbara - superpolynom
Beräkningsbara
(n!, nn, …)
- Vi vill ha den snabbaste!
Ej beräkningsbara
✴Att implementera
✴Att köra
31
Hanterbara - polynom
1+n2+3*n
Johan Eliasson
Stora Ordo
f(n) ≤ c*g(n) => f(n) är av O(g(n))
Johan Eliasson
O(definition)
cg(n)
f(n)
n0
32
Definition:
Givet funktionerna f(n) och g(n) säger vi att f(n) är
O(g(n)) omm f(n) ≤ c*g(n) för n ≥ n0 och c >0 och n0≥1
Storlek på indata
33
Johan Eliasson
34
Johan Eliasson
Litet räkneexempel
f(n) är O(g(n))
• Varför inte f(n) ≤ O(g(n)) • 1 operation tar 1µs
• 1*10 element i en lista
• Kvadratisk sorteringsalgoritm n
eller f(n) ≈ O(g(n))
•
9
Borde vara
2
- f(n) tillhör O(g(n)) ty O(g(n)) är en mängd
funktioner,
- 31000år
• Sorteringsalgoritm O(n*log(n))
✴Se bilden.
- 30000s ≈ 1 arbetsdag
- Men vi skriver f(n) är O(g(n))
•n
•n
2 och
dubbelt så snabb => 15500 år
2 och1000
35
gånger så snabb => 31år
36
Johan Eliasson
Exekveringstider - en dator med 100 000 MIPS, 1*10
11
op/sek
Johan Eliasson
Ohanterbarhet
• Många triviala att förstå och viktiga att lösa
10
20
50
100
300
N2
1*10-9
2.5*10-8
1/400
1*10-7
9*10-7
- Schemaläggning
N5
1*10-6
3.2*10-5
3.1*10-3
0.1
24,3 s
- Handelsresande
2N
1*10-8
1*10-5
3 tim
4*1011 år
6,5*1071
år
NN
0.1
33
2.8*1066
miljoner år år
9*10162 år
1.4 *10632
år
• Moore’s lag förändrar den situationen?
• Hur hanterar vi ohanterbarhet?
! Drygt 10 miljarder µs på en dag
! 1*1024 µs sedan ”Big Bang”
37
38
Johan Eliasson
Hantera ohanterbarhet
Johan Eliasson
NP-kompletta problem
• Heuristik
• En speciell klass av ohanterliga problem
• Har problem X en lösning med egenskaperna Y
• Ekvivalenta:
Icke hanterbara - - Lösa nästan rätt problem
✴Förenkling
- Transformeras
- Lösa problemet nästan rätt
superpolynom
(n!, nn, …)
- Högst exponentiella
✴Approximation
- Saknar bevis för ohanterbarhet
39
Johan Eliasson
40
Johan Eliasson
Mäta tidsåtgången
Exempel
• Hur ska vi mäta tidsåtgången?
t(ms)
- Experimentell analys
✴ Implementera algoritmen
✴ Kör programmet med varierande datamängd
• Storlek
• Sammansättning
✴ Använd metoder för tidtagning så som
• time (ger tiden i sekunder sedan 1970), clock (ger processortid
med hyfsad precision) eller gettimeofday (bättre precision än
time, men ej standard i c)
n
✴ Plotta uppmätt data
41
Johan Eliasson
Bästa, värsta & medel
42
Johan Eliasson
Experimentell analys…
• Begränsningar med metoden
- Måste implementera och testa algoritmen
Värsta
- Svårt att veta om programmet har stannat eller fast i
beräkningarna. T ex. 2n; n=100 => 40000 billioner år
Medel
Bästa
- Experimenten kan endast utföras på en begränsad mängd av
data, man kan missa viktiga testdata
- Hårdvaran och mjukvaran måste vara den samma för alla
implementationer
43
Johan Eliasson
Kontrollera sin slutsats
44
Johan Eliasson
Generellare metod behövs
• Plotta uppmätna tiden/uppskattade ( f(n)/g(n) enl.
använder en högnivåbeskrivning av algoritmerna
• Som
istället för en implementation av den
ordodef.)
• Borde gå mot konstant eller 0 för stora värden om
korrekt
• Tar hänsyn till alla möjliga indata
• Analys oberoende av hårdvaran och mjukvaran
• Asymptotisk analys
n
45
Johan Eliasson
46
Johan Eliasson
Asymptotisk analys
Lite matematik behövs…
• Logaritmer
• Utgår från pseudokoden
• Räkna operationer
- logb(xy) = logb(x) + logb(y)
- Ställ upp ett uttryck för antalet
operationer beroende av
problemstorleken
- logb(x/y) = logb(x) - logb(y)
- logb(xα) = α logb(x)
• Förenkla tidsuttrycket
• Ta fram en funktion som
- logb(a) =logx(a)/logx(b)
begränsar tidsuttrycket
ovanifrån…
47
48
Johan Eliasson
Kanske lite mer…
Och ännu mer matte…
• Exponenter
• Summor är bra att kunna…
a(b +c ) = a b a c
- Generell definition
a bc = (a b ) c
t
∑ f (i) = f (s) + f (s + 1) + f (s + 2) + ... f (t)
i= s
a b /a c = a(b−c )
b = a log a (b )
€
Johan Eliasson
- Geometrisk utveckling (n≥0 och 0<a ≠ 1)
n
€
∑a
i
= 1+ a + a 2 + a 3 + ...+ a n =
i= 0
€
b c = a c*log a (b )
1− a n +1
1− a
✴Växer exponentiellt (om a>1)
€
€
49
€
50
Johan Eliasson
Johan Eliasson
€
Sista matten för denna gång…
• Aritmetisk tillväxt, summera alla tal från 1 t o m 100
Analys av algoritmer
• Primitiva operationer
- Lågnivå beräkningar som är i stort sett oberoende av
programspråk och kan definieras i termer av pseudokod:
n+1
n
✴ Anropa en metod/funktion
✴ Returnera från en metod/funktion
✴ Utföra en aritmetisk operation (+, -, …)
1
n
∑ i = 1+ 2 + 3 + ...+ n =
i=1
€
2
n +n
2
0
1
2 3
n/2
✴ Jämföra två tal, etc.
n
✴ Referera till en/ett variabel/objekt
✴ Indexera i en array
51
Johan Eliasson
52
Johan Eliasson
Exempel 1
Mer analys av algoritmer…
• Inspektera pseudokoden och räkna antalet
Algorithm addAllEven(n)
primitiva operationer.
• Väldig abstraktion, vi bortser från hårdvaran, och
att olika operationer tar olika lång tid, …
•
Alternativet är att titta på de verkliga tiderna för
de olika operationerna
- Ger en maskinberoende analys
sum <- 0
1
i <- 2
1
while i<=n do
(n/2+1)*1 +(n/2)*[]
sum <- sum+i
1+1
i <- i+2
1+1
return sum;
1
T(n)=1+1+(n/2+1)*1 +(n/2)*(1+1+1+1)+1=4n+n/2+4
53
54
Johan Eliasson
Exempel 2
Jämföra T(n)
• Rita kurvor för T(n) och jämför…svårt…
• Alternativet är asymptotisk notation/analys
Algorithm arrayMax(A,n)
input: An array A storing n integers
output: The maximum element in A
currentMax ←
for i ←
Johan Eliasson
- Förenkla jämförelsen genom att avrunda T(n)
//1+1
A[0]
" 1.000001 ≈ 1
" 3n2 ≈ n2
//1+n(1+1)+(n-1)*([]+1)
1 to n-1 do
//1+1+1
if currentMax < A[i] then
//1+1
currentMax ← A[i]
//1
return currentMax
Tmax(n)= 3+2n+(n-1)*6 +1 = 8n-2
Tmin(n)= 3+2n+(n-1)*4 +1 = 6n
55
56
Johan Eliasson
Stora Ordo
f(n) ≤ c*g(n) => f(n) är av O(g(n))
Johan Eliasson
Mer ordo
cg(n)
•
f(n) = 7n -3 hitta en funktion som begränsar f(n)?
- Oändligt många, hitta den ”minsta”/enklaste
f(n)
- Droppa allt utom den ledande termen dvs. lägre ordningens
termer och konstanter
✴7n-3 är O(n)
✴8n2log(n) + 5n2+n är O(n2log(n))
n0
Storlek på indata
57
Johan Eliasson
58
Johan Eliasson
Exempel
Specialla klasser av algoritmer
• Logaritmiska O(log(n))
O(n)
• Linjära
O(n )
• Kvadradiska
O(n ); k≥1
• Polynoma
• Exponentiella O(a ); n≥1
• log(n) <<n<<n <<n <<2
•
n
n
€
59
f (n)
+1
g(n)
60
Johan Eliasson
O(sammanfattning)
Johan Eliasson
O(varning)
används för att utrycka antalet primitiva
• O(n)
operationer som utförs som en funktion av storleken
på indata
• En övre gräns för tillväxt
• arrayMax är en linjär algoritm dvs O(n)
• En algoritm som körs på O(n) är bättre än en O(n ),
2
men O(log(n)) är bättre än O(n)
- log(n) <<n<<n2<<n3<<2n
61
n →∞
% 7n − 3 (
%
3(
lim'
* + 1 = lim' 7 − * + 1 ⇒ c = 8
n →∞&
n →∞&
n )
n)
#n0?
$7n-3≤8n; n0 =1? €
$Ok!
k
3
lim
- Hitta c
2
2
F(n) = 7n-3 är O(n)
•
Var aktsam, stora konstanter ställer till det
– T(n)=1000000n är en linjär algoritm O(n), men i många fall
mycket mindre effektiv på data mängder än en algoritm med
T(n) = 2n2 som är O(n2)
- O-notationen är en stor förenkling, dvs en övre gräns, det
finns släktingar som begränsar nedåt
- Samt tagit bort kopplingen
till hårdvaran.
62
Johan Eliasson
O(genväg)
Johan Eliasson
O(exempel 1)
• Man kan många gånger skippa vägen över T(n)
Algorithm prefixAv1(X);
Input: An n-element Array of numbers
- Väldigt grov uppskattning av tillväxten
Output: An n-element Array of numbers such that A[i] is the
- Man gör en okulärbesiktning av algoritmen
average of X[0],…,X[i].
Let A be an array of numbers
✴ Initiera en array är O(n)
for i ← 0 to n-1 do
✴ Nästlade loopar är O(n)*O(n)*…*O(n)≈O(nk)
a ← 0
Analys: Tb(n) = ? Tw(n) = ?
Men algoritmen är av O(n2)
for j ← 0 to i do
a ← a+X[j]
A[i] ←a/(i+1)
return A
63
Johan Eliasson
64
Johan Eliasson
O(exempel 2)
Fler definitioner
• T(n)=Ω(g(n)) omm det finns positiva konstanter c och
Algorithm prefixAv1(X);
Input: An n-element Array of numbers
n0 så att T(n)≥cg(n) när n≥ n0
Output: An n-element Array of numbers such that A[i] is the
average of X[0],…,X[i].
• T(n)=Θ(h(n)) omm T(n)=O(h(n)) och T(n)= Ω(h(n))
• T(n)=o(p(n)) omm T(n) = O(p(n)) och T(n)≠Θ(p(n))
Let A be an array of numbers
s ← 0
Analys: T(n) = ?
Men algoritmen är av O(n)
for i ← 0 to n-1 do
s ← s+X[i]
A[i] ←s/(i+1)
return A
65
Johan Eliasson
Beräkna minnesåtgång
• Vi kan använda liknande metoder som för asymptotisk
analys.
- Men i stället för att beräkna primitiva operationer
så räknar vi hur mkt minne vi behöver utöver den
initiala problembeskrivningen
- Glöm inte minnet för lokala variabler etc som läggs
upp på stacken vid rekursion
67
Johan Eliasson
66
Johan Eliasson