Dokumentieren 19064809

Werbung
Übung Algorithmen I
03.05.2017
Björn Kaidel
[email protected]
(Mit Folien von Lukas Barth, Lisa Kohl, Julian Arz, Timo Bingmann,
Sebastian Schlag und Christoph Striecks)
Roadmap
I Organisatorisches
I Ezienz von Algorithmen, O-Kalkül
I Korrektheit von Algorithmen
I Teile-und-Herrsche-Paradigma
I Master-Theorem
Orga im Schnelldurchlauf - Wo nde ich Was?
I Homepage:
http://crypto.iti.kit.edu/index.php?id=799
I Diskussionen, Peer-to-Peer-Fragen: ILIAS-Forum
I Mailingliste
I Feedbackkasten
Übungsleiter
Björn Kaidel [email protected]kit.edu
Sascha Witt [email protected]
Sebastian Schlag
Orga im Schnelldurchlauf - Tutorien
I Tutoreinteilung durch WebInScribe abgeschlossen
I Wer ein Montagstutorium zugewiesen bekommen hat,
besucht diese Woche bitte irgendein anderes Tutorium!
Orga im Schnelldurchlauf - Übungsblätter
I Ausgabe: Montag
I Abgabe: Darauf folgender Dienstag, bis 12:45 Uhr
I Übungsblatt 1 online
I
Anm: In Aufgabe 2 gab es einen Fehler, wurde korrigiert!
Algorithmen
Ezienz von Algorithmen
I Algorithmen haben gewisse Laufzeit und benötigen
Speicherplatz
Ezienz von Algorithmen
I Algorithmen haben gewisse Laufzeit und benötigen
Speicherplatz
I In Algorithmen I interessieren wir uns hauptsächlich für
die Laufzeit
Ezienz von Algorithmen
I Algorithmen haben gewisse Laufzeit und benötigen
Speicherplatz
I In Algorithmen I interessieren wir uns hauptsächlich für
die Laufzeit
I Ziel: Schnelle & eziente Algorithmen
Ezienz von Algorithmen
I Algorithmen haben gewisse Laufzeit und benötigen
Speicherplatz
I In Algorithmen I interessieren wir uns hauptsächlich für
die Laufzeit
I Ziel: Schnelle & eziente Algorithmen
I Fragen:
I
Was heiÿt schnell?
I
Wie bestimmt und misst man die Laufzeit eines
Algorithmus?
Ezienz von Algorithmen
I Algorithmen können sich in ihrer Ezienz stark unterscheiden
Ezienz von Algorithmen
I Algorithmen können sich in ihrer Ezienz stark unterscheiden
I Beispiel: Sortieren von
n
Zahlen (aus [CLRS04])
Sortieren durch Einfügen
Sortieren durch Mischen
c1 · n2
c2 · n log n
Ezienz von Algorithmen
I Algorithmen können sich in ihrer Ezienz stark unterscheiden
I Beispiel: Sortieren von
n
Zahlen (aus [CLRS04])
Sortieren durch Einfügen
Sortieren durch Mischen
c1 · n2
c2 · n log n
I Üblicherweise gilt
c1 < c2
Ezienz von Algorithmen
I Setze
n = 106 , c1 = 2
und
Sortieren durch Einfügen
2
· (106 )2
Anw.
Rechner mit 2 GHz
c2 = 50
Sortieren durch Mischen
50
· 106 log 106
Anw.
Rechner mit 500 MHz
Ezienz von Algorithmen
I Setze
n = 106 , c1 = 2
und
c2 = 50
Sortieren durch Einfügen
2
· (106 )2
Anw.
50
Rechner mit 2 GHz
2
·(106 )2
Anw.
2 109 Anw. pro sec
·
= 1000
Sortieren durch Mischen
· 106 log 106
Anw.
Rechner mit 500 MHz
sec
· 6 log 106
·
50 10
Anw.
500 106 Anw. pro sec
= 0.6
sec
Ezienz von Algorithmen
I Setze
n = 106 , c1 = 2
und
c2 = 50
Sortieren durch Einfügen
2
· (106 )2
Anw.
50
Rechner mit 2 GHz
2
·(106 )2
Anw.
2 109 Anw. pro sec
·
I Mit
= 1000
Sortieren durch Mischen
· 106 log 106
Anw.
Rechner mit 500 MHz
sec
· 6 log 106
·
50 10
Anw.
500 106 Anw. pro sec
= 0.6
n = 107 :
Sortieren durch Einfügen
≈ 27.8
h
Sortieren durch Mischen
7 sec
sec
Generelles Beispiel
I Laufzeit mit 109 Anw. pro Sekunde unter Eingabegröÿe
n
n
µs
µs
µs
µs
µs
µs
µs
µs
µs
µs
1000 log2
10
3.3
50
5.6
100
6.6
500
9.0
10
3
10.0
10
4
13.3
10
5
16.6
10
6
20
10
7
23
10
8
27
500n
5
25
50
250
500
µs
µs
µs
µs
µs
100n log2
3.3
28.2
66.4
448
n
µs
µs
µs
µs
10n
1
25
100
2
µs
µs
µs
2.5 ms
1
125
n3
µs
µs
1 ms
125 ms
1 ms
10 ms
1 s
5 ms
13.3 ms
1 s
16 min
11.6 d
50 ms
166 ms
100 s
500 ms
2 s
2.7 h
5 s
23 s
11.6 d
50 s
4.4 min
3.2 a
31.7 a
.
a
.
10
a
10
4 5
7 5
n
n
2
1
µs
13 h
10
13
a
Eingabegröÿe und Laufzeit
I Eingabegröÿe:
I
hängt vom betrachteten Problem ab
I
Sortieren: Anzahl der Datensätze
I
Multiplikation: Anzahl der Bits (Darstellung der Zahlen)
I
Graph: Anzahl der Knoten und Kanten
Eingabegröÿe und Laufzeit
I Eingabegröÿe:
I
hängt vom betrachteten Problem ab
I
Sortieren: Anzahl der Datensätze
I
Multiplikation: Anzahl der Bits (Darstellung der Zahlen)
I
Graph: Anzahl der Knoten und Kanten
I Laufzeit:
I
Anzahl der ausgeführten Grundoperationen (Schritte)
I
gängige Annahme: jede Zeile im Pseudocode hat
konstanten Zeitaufwand
I
I
Achtung: trit nicht auf Algorithmenaufrufe zu!
Aufsummieren der Kosten jeder ausgeführten Zeile ergibt
im wesentlichen Laufzeit
Genauer: (asymptotische) Laufzeit
I Bestimmung im günstigsten, mittleren und schlechtesten
Fall möglich
Genauer: (asymptotische) Laufzeit
I Bestimmung im günstigsten, mittleren und schlechtesten
Fall möglich
I üblich ist Bestimmung im schlechtesten Fall:
I
Laufzeit ist obere Schranke einer beliebigen Eingabe
I
bei vielen Problemen: tritt recht häug auf
I
böse Instanzen?
Genauer: (asymptotische) Laufzeit
I Bestimmung im günstigsten, mittleren und schlechtesten
Fall möglich
I üblich ist Bestimmung im schlechtesten Fall:
I
Laufzeit ist obere Schranke einer beliebigen Eingabe
I
bei vielen Problemen: tritt recht häug auf
I
böse Instanzen?
I asymptotisch: Gröÿe der Eingabe geht gegen unendlich
(Asymptotische) O-Notation
O(g (n))
= {f (n) :
sodass 0
es exist. pos. Konstanten
≤ f (n) ≤ c · g (n)
c
für alle
und
n0 ,
n ≥ n0 }
O-Notation (Intuition)
O(g (n))
= {f (n) :
sodass 0
es exist. pos. Konstanten
≤ f (n) ≤ c · g (n)
c
für alle
und
n0 ,
n ≥ n0 }
150
100
f1 (n)
50
0
0
10
20
30
40
50
60
70
80
90
100
O-Notation (Intuition)
O(g (n))
= {f (n) :
sodass 0
es exist. pos. Konstanten
≤ f (n) ≤ c · g (n)
c
für alle
und
n0 ,
n ≥ n0 }
150
100
c1 · n
f1 (n)
50
0
0
10
20
30
40
50
60
70
80
90
100
O-Notation (Intuition)
O(g (n))
= {f (n) :
sodass 0
es exist. pos. Konstanten
≤ f (n) ≤ c · g (n)
c
für alle
und
n0 ,
n ≥ n0 }
150
c2 · n
100
f1 (n)
50
0
0
10
20
30
40
50
60
70
80
90
100
O-Notation (Intuition)
O(g (n))
= {f (n) :
sodass 0
es exist. pos. Konstanten
≤ f (n) ≤ c · g (n)
c
für alle
und
n0 ,
n ≥ n0 }
150
c2 · n
100
f1 (n) ∈ O(n)
50
n0 →
0
0
10
20
30
40
50
60
70
80
90
100
O-Notation (Intuition)
O(g (n))
= {f (n) :
sodass 0
es exist. pos. Konstanten
≤ f (n) ≤ c · g (n)
150
c
für alle
und
n0 ,
n ≥ n0 }
f2 (n) ∈
/ O(n)
c2 · n
100
f1 (n) ∈ O(n)
50
n0 →
0
0
10
20
30
40
50
60
70
80
90
100
O-Notation (Intuition)
O(g (n))
= {f (n) :
sodass 0
es exist. pos. Konstanten
≤ f (n) ≤ c · g (n)
150
c
für alle
und
n0 ,
n ≥ n0 }
f2 (n) ∈ Ω(n)
100
c3 · n
f1 (n) ∈ Ω (n)
50
n0 →
0
0
10
20
30
40
50
60
70
80
90
100
(Asymptotische) Ω-Notation (Intuition)
Ω(g (n)) = {f (n) :
sodass 0
es exist. pos. Konstanten
≤ c · g (n) ≤ f (n)
c
für alle
und
n0 ,
n ≥ n0 }
Ω-Notation (Intuition)
Ω(g (n)) = {f (n) :
sodass 0
es exist. pos. Konstanten
≤ c · g (n) ≤ f (n)
150
c
für alle
und
n0 ,
n ≥ n0 }
f2 (n) ∈ Ω(n)
100
c1 · n
50
n0 →
0
0
10
20
30
40
50
60
70
80
90
100
Asymptotische Notationen
O(g (n))
= {f (n) :
sodass 0
Θ(g (n)) = {f (n) :
sodass 0
Ω(g (n)) = {f (n) :
sodass 0
es exist. pos. Konstanten
≤ f (n) ≤ c · g (n)
c
für alle
es exist. pos. Konstanten
und
n ≥ n0 }
c1 , c2
≤ c1 · g (n) ≤ f (n) ≤ c2 · g (n)
es exist. pos. Konstanten
≤ c · g (n) ≤ f (n)
c
für alle
n0 ,
und
und
n0 ,
für alle
n0 ,
n ≥ n0 }
n ≥ n0 }
Asymptotische Notationen
o(g (n))
= {f (n) :
sodass 0
ω(g (n)) = {f (n) :
sodass 0
für
alle
pos. Konstanten
≤ f (n) ≤ c · g (n)
für
alle
für alle
pos. Konstanten
≤ c · g (n) ≤ f (n)
c
c
für alle
existiert ein
n0 ,
n ≥ n0 }
existiert ein
n0 ,
n ≥ n0 }
Anm.: Notation wird O-Notation oder Landau-Notation genannt.
Nochmal anschaulich...
ω(g (n)) = {f (n) :
für
sodass 0
alle
pos. Konstanten
≤ c · g (n) ≤ f (n)
c
für alle
existiert ein
n0 ,
n ≥ n0 }
150
f2 (n) ∈ Ω (n)
100
c1 · n
f1 (n) ∈ Ω (n)
50
0
0
10
20
30
40
50
60
70
80
90
100
Nochmal anschaulich...
ω(g (n)) = {f (n) :
für
sodass 0
alle
pos. Konstanten
≤ c · g (n) ≤ f (n)
c
für alle
existiert ein
n0 ,
n ≥ n0 }
150
c2 · n
?
f2 (n) ∈ ω(n)
100
f1 (n) ∈
/ ω(n)
50
0
0
10
20
30
40
50
60
70
80
90
100
Betrachtung über Grenzwerte
Für nicht-negative
f,g : N → R
I
f (n) ∈ o(g (n))
I
f (n) ∈ ω(g (n))
I
f (n) ∈ Θ(g (n))
gelten folgende Äquivalenzen:
⇐⇒
lim
n→∞
⇐⇒
⇐=
lim sup
n→∞
0
<
lim
n→∞
f (n)
= 0,
g (n)
f (n)
= ∞,
g (n)
f (n)
= c < ∞.
g (n)
Betrachtung über Grenzwerte
Für nicht-negative
I
f,g : N → R
f (n) ∈ O(g (n)) ⇐⇒
0
gelten folgende Äquivalenzen:
≤ lim sup
n→∞
I
f (n) ∈ Ω (g (n))
⇐⇒
0
f (n)
= c < ∞,
g (n)
< lim inf
n→∞
f (n)
≤ ∞,
g (n)
Betrachtung über Grenzwerte: Beispiel
Gilt 5n
∈ O(n )?
2
Betrachtung über Grenzwerte: Beispiel
Gilt 5n
∈ O(n )?
2
f (n)
5n
5
=
=
g (n)
n
n
2
lim
n→∞
5
n
=0
Betrachtung über Grenzwerte: Beispiel
Gilt 5n
∈ O(n )?
2
f (n)
5n
5
=
=
g (n)
n
n
2
lim
n→∞
I
f (n) ∈ o(g (n))
5
n
=0
⇐⇒
lim
n→∞
f (n)
= 0,
g (n)
Betrachtung über Grenzwerte: Beispiel
Gilt 5n
∈ O(n )?
2
f (n)
5n
5
=
=
g (n)
n
n
2
lim
n→∞
I
I
f (n) ∈ o(g (n))
5
n
=0
⇐⇒
f (n) ∈ O(g (n)) ⇐⇒
0
lim
n→∞
≤ lim sup
n→∞
f (n)
= 0,
g (n)
f (n)
= c < ∞,
g (n)
Betrachtung über Grenzwerte: Beispiel
Gilt 5n
∈ O(n )?
2
f (n)
5n
5
=
=
g (n)
n
n
2
lim
n→∞
I
f (n) ∈ Ω (g (n))
5
n
=0
⇐⇒
0
< lim inf
n→∞
f (n)
≤ ∞,
g (n)
Ein kniigeres Beispiel...
f (x) = sin(x) + 2
4
sin(x)
+2
2
0
0
100
200
300
400
500
600
700
800
900 1,000
Ein kniigeres Beispiel...
f (x) = sin(x) + 2 ∈ Θ(1)?
4
4
·1
sin(x)
+2
2
0 .5
0
0
100
200
300
400
·1
500
600
700
800
900 1,000
Ein kniigeres Beispiel...
f (x) = sin(x) + 2 ∈ Θ(1)?
4
4
·1
sin(x)
+2
2
0 .5
0
0
I
100
200
300
f (n) ∈ Θ(g (n))
400
·1
500
⇐=
600
0
<
900 1,000
700
800
lim
n→∞
f (n)
=c <∞
g (n)
Ein kniigeres Beispiel...
f (x) = sin(x) + 2 ∈ Θ(1)?
4
4
·1
sin(x)
+2
2
0 .5
0
0
100
200
300
I
f (n) ∈ O(g (n))
400
·1
500
⇐⇒
0
600
700
≤ lim sup
n→∞
800
900 1,000
f (n)
=c <∞
g (n)
Ein kniigeres Beispiel...
f (x) = sin(x) + 2 ∈ Θ(1)?
4
4
·1
sin(x)
+2
2
0 .5
0
0
I
100
200
300
400
f (n) ∈ Ω (g (n))
·1
500
⇐⇒
600
0
700
800
< lim inf
n→∞
900 1,000
f (n)
≤∞
g (n)
Basis des Logarithmus
I O(log n), aber zu welcher Basis?
Basis des Logarithmus
I O(log n), aber zu welcher Basis?
I Üblicherweise zur Basis 2 in der Informatik
I Innerhalb der O-Notation egal
Basis des Logarithmus
I O(log n), aber zu welcher Basis?
I Üblicherweise zur Basis 2 in der Informatik
I Innerhalb der O-Notation egal
I Denn:
O(logb
für beliebige
a, b
n) = O(
(loga
b
n
) = O(loga n),
loga b
loga
ist unabhängig von
n)
Korrektheit von Algorithmen
Invarianten
Schleifeninvarianten
I Wäre es nicht schön,
beweisen
zu
können, dass der Algorithmus das
richtige tut?
http://xkcd.com/1195/
Invarianten
Schleifeninvarianten
I Wäre es nicht schön,
beweisen
zu
können, dass der Algorithmus das
richtige tut?
I Wenigstens für einzelne Schleifen?
http://xkcd.com/1195/
Invarianten
Schleifeninvarianten
I Wäre es nicht schön,
beweisen
zu
können, dass der Algorithmus das
richtige tut?
I Wenigstens für einzelne Schleifen?
Idee
I Finde etwas, das vor und nach jedem
Schleifendurchlauf gilt
I Beweise induktiv
http://xkcd.com/1195/
Invarianten
Schleifeninvarianten
1.
2.
Initialisierung: Invariante gilt vor erster Iteration
Fortsetzung: Invariante gilt vor Iteration i
⇒
3.
Invariante gilt vor Iteration
i +1
Terminierung: Abbruchbed. erfüllt ∧ Invariante gilt
⇒
richtiges Ergebnis / Nachbedingung erfüllt
Invarianten
Schleifeninvarianten
1.
2.
Initialisierung: Invariante gilt vor erster Iteration
Fortsetzung: Invariante gilt vor Iteration i
⇒
3.
Invariante gilt vor Iteration
i +1
Terminierung: Abbruchbed. erfüllt ∧ Invariante gilt
⇒
richtiges Ergebnis / Nachbedingung erfüllt
I Wenn 1. und 2. erfüllt, dann ist Invariante wahr vor jeder
Iteration der Schleife (Ähnlichkeit zur mathematischen
Induktion, IA und IS)
I 3. Eigenschaft unterscheidet sich zur mathematischen
Induktion, da Schleife abbricht
Invarianten
Zusicherungen und Invarianten
I Vorbedingungen
I (Schleifen-)Invarianten
I Nachbedingungen
Invarianten
Zusicherungen und Invarianten
I Vorbedingungen
I (Schleifen-)Invarianten
I Nachbedingungen
Function
invExample(a :
R; n
0
p =a : R; r =1 : R; n=n
while n > 0 do
0
:
N) : R
:
N
if n is odd then do something
else do something else
return r
Invarianten
Zusicherungen und Invarianten
I Vorbedingungen
I (Schleifen-)Invarianten
I Nachbedingungen
Function invExample(a : R; n
assert Vorbedingung
0
p =a : R; r =1 : R; n=n
while n > 0 do
0
:
N) : R
:
N
if n is odd then do something
else do something else
return r
Invarianten
Zusicherungen und Invarianten
I Vorbedingungen
I (Schleifen-)Invarianten
I Nachbedingungen
Function invExample(a : R; n
assert Vorbedingung
0
p =a : R; r =1 : R; n=n
while n > 0 do
0
:
N) : R
:
N
if n is odd then do something
else do something else
assert Nachbedingung
return r
Invarianten
Zusicherungen und Invarianten
I Vorbedingungen
I (Schleifen-)Invarianten
I Nachbedingungen
Function invExample(a : R; n
assert Vorbedingung
0
p =a : R; r =1 : R; n=n
while n > 0 do
0
:
N) : R
:
N
invariant Schleifeninvariante
if n is odd then do something
else do something else
assert Nachbedingung
return r
Invarianten
Idee der Anwendung
I nde Schleifeninvariante
I zeige Schleifeninvariante
I Schleifeninvariante und sonstiges Wissen
⇒
Korrektheit des Algorithmus
Invarianten
Idee der Anwendung
I nde Schleifeninvariante
I zeige Schleifeninvariante
I Schleifeninvariante und sonstiges Wissen
⇒
Korrektheit des Algorithmus
Function max(A : Array [0..n − 1] of N≥ ) :
assert A.size() > 0
//
0
Vorbedingung
i =0 : N≥
j =1 : N≥
while j < n do
if A[j] > A[i] then i := j
0
0
++j
assert i = argmax`<n A[`]
return i
//
Nachbedingung
Invarianten
Beispiel I
Function max(A : Array [0..n − 1] of N≥ ) :
assert A.size() > 0
//
0
Vorbedingung
i =0 : N≥
j =1 : N≥
while j < n do
0
0
if A[j] > A[i] then i := j
++j
assert i = argmax`<n A[`]
return i
//
Nachbedingung
Invarianten
Beispiel I
Function max(A : Array [0..n − 1] of N≥ ) :
assert A.size() > 0
//
0
i =0 : N≥
j =1 : N≥
while j < n do
invariant i = argmax`<j A[`]
if A[j] > A[i] then i := j
Vorbedingung
0
0
++j
assert i = argmax`<n A[`]
return i
//
//
Invariante
Nachbedingung
Invarianten
Beispiel I
while j < n do
invariant i = argmax`<j A[`]
if A[j] > A[i] then i := j
++j
I
j = 1:
klar
//
Invariante
Invarianten
Beispiel I
while j < n do
invariant i = argmax`<j A[`]
if A[j] > A[i] then i := j
//
++j
I
I
j = 1: klar
j → j + 1: es gilt i = argmax`<j+ A[`],
A[i] = max`<j+ A[`]
1
1
also
Invariante
Invarianten
Beispiel I
while j < n do
invariant i = argmax`<j A[`]
if A[j] > A[i] then i := j
//
Invariante
++j
I
I
j = 1: klar
j → j + 1: es gilt i = argmax`<j+ A[`],
A[i] = max`<j+ A[`]
1
also
1
A[j + 1] > A[i] = max`<j+1 A[`] →
i = j + 1 → Gültig
1. Fall 1:
update
Invarianten
Beispiel I
while j < n do
invariant i = argmax`<j A[`]
if A[j] > A[i] then i := j
//
Invariante
++j
I
I
j = 1: klar
j → j + 1: es gilt i = argmax`<j+ A[`],
A[i] = max`<j+ A[`]
1
also
1
A[j + 1] > A[i] = max`<j+1 A[`] →
i = j + 1 → Gültig
Fall 2: A[j + 1] ≤ A[i] = max`<j+1 A[`] →
→ Gültig
1. Fall 1:
update
2.
kein update
Invarianten
Beispiel I
Function max(A : Array [0..n − 1] of R) :
assert A.size() > 0
//
i =0 : N≥
j =1 : N≥
while j < n do
invariant i = argmax`<j A[`]
if A[j] > A[i] then i := j
Vorbedingung
0
0
++j
assert i = argmax`<n A[`]
return i
I nach Beenden der Schleife gilt:
I
I
//
//
j =n
und
i = argmax`<j A[`]
⇒ Nachbedingung gilt: i = argmax`<n A[`]
⇒ Algorithmus liefert korrektes Ergebnis
Invariante
Nachbedingung
Invarianten
Beispiel II
Function
funWithAlgorithms(n :
N)
:
//
keine Vorbedingung
Z := {1, . . . , n}
while |Z | > 1 do
a, b with a 6= b from Z
Z ← Z \{a, b} // enferne zwei zufällige Zahlen aus Z
Z ← Z ∪ {a · b}
// füge a · b hinzu
assert |Z | = 1
// Nachbedingung I
pick
return Z [0]
Invarianten
Beispiel II
Ziel: Zeige die Zahl die übrig bleibt ist n!
Function
funWithAlgorithms(n :
N)
:
//
keine Vorbedingung
Z := {1, . . . , n}
while |Z | > 1 do
a, b with a 6= b from Z
Z ← Z \{a, b} // enferne zwei zufällige Zahlen aus Z
Z ← Z ∪ {a · b}
// füge a · b hinzu
assert |Z | = 1
// Nachbedingung I
assert Z [0] = n!
// Nachbedingung II
return Z [0]
pick
Invarianten
Beispiel II
Ziel: Zeige die Zahl die übrig bleibt ist n!
Function
funWithAlgorithms(n :
N)
:
//
keine Vorbedingung
Z := {1, . . . , n}
while |Z | > 1 do Q
invariant S := z∈Z z = n!
// Invariante
pick a, b with a 6= b from Z
Z ← Z \{a, b} // enferne zwei zufällige Zahlen aus Z
Z ← Z ∪ {a · b}
// füge a · b hinzu
assert |Z | = 1
// Nachbedingung I
assert Z [0] = n!
// Nachbedingung II
return Z [0]
Invarianten
Beispiel II
I IA:
S=
Invarianten
Beispiel II
I IA:
S=
Qn
i=1
i = n!
Invarianten
Beispiel II
I IA:
S=
Qn
i = n!
Q
S = z∈Z z = n!
i=1
I IS: Annahme
Invarianten
Beispiel II
I
Qn
i = n!
Q
IS: Annahme S =
z = n!
Q z∈Z
0
zu zeigen: S :=
z∈Z \{a,b}∪{a·b} z = n!
I IA:
S=
i=1
Invarianten
Beispiel II
I
Qn
i = n!
Q
IS: Annahme S =
z = n!
Q z∈Z
0
zu zeigen: S :=
z∈Z \{a,b}∪{a·b} z = n!
I IA:
S=
i=1
Beweis:
S0 = S ·
=S
= n!
1
·
1
a b
· (a · b)
Invarianten
Beispiel II
I
Qn
i = n!
Q
IS: Annahme S =
z = n!
Q z∈Z
0
zu zeigen: S :=
z∈Z \{a,b}∪{a·b} z = n!
I IA:
S=
i=1
Beweis:
S0 = S ·
1
·
1
a b
· (a · b)
=S
= n!
Also bleibt
S0 =
Q
z∈Z \{a,b}∪{a·b}
z = n!
Invarianten
Beispiel II
Function
funWithAlgorithms(n :
N)
:
//
keine Vorbedingung
Z := {1, . . . , n}
while |Z | > 1 do Q
invariant S := z∈Z z = n!
// Invariante
pick a, b with a 6= b from Z
Z ← Z \{a, b} // enferne zwei zufällige Zahlen aus Z
Z ← Z ∪ {a · b}
// füge a · b hinzu
assert |Z | = 1
// Nachbedingung I
assert Z [0] = n!
// Nachbedingung II
return Z [0]
Invarianten
Beispiel II
Function
funWithAlgorithms(n :
N)
:
//
keine Vorbedingung
Z := {1, . . . , n}
while |Z | > 1 do Q
invariant S := z∈Z z = n!
// Invariante
pick a, b with a 6= b from Z
Z ← Z \{a, b} // enferne zwei zufällige Zahlen aus Z
Z ← Z ∪ {a · b}
// füge a · b hinzu
assert |Z | = 1
// Nachbedingung I
assert Z [0] = n!
// Nachbedingung II
return Z [0]
I nach Beenden der Schleife gilt:
S :=
Q
z∈Z
z = n!
|Z | = 1
und
Invarianten
Beispiel II
Function
funWithAlgorithms(n :
N)
:
//
keine Vorbedingung
Z := {1, . . . , n}
while |Z | > 1 do Q
invariant S := z∈Z z = n!
// Invariante
pick a, b with a 6= b from Z
Z ← Z \{a, b} // enferne zwei zufällige Zahlen aus Z
Z ← Z ∪ {a · b}
// füge a · b hinzu
assert |Z | = 1
// Nachbedingung I
assert Z [0] = n!
// Nachbedingung II
return Z [0]
I nach Beenden der Schleife gilt:
|Z | = 1
Q
I
S := z∈Z z = n!
⇒ Nachbedingung
gilt:
Z [0] = n!
und
Invarianten
Beispiel II
Function
funWithAlgorithms(n :
N)
:
//
keine Vorbedingung
Z := {1, . . . , n}
while |Z | > 1 do Q
invariant S := z∈Z z = n!
// Invariante
pick a, b with a 6= b from Z
Z ← Z \{a, b} // enferne zwei zufällige Zahlen aus Z
Z ← Z ∪ {a · b}
// füge a · b hinzu
assert |Z | = 1
// Nachbedingung I
assert Z [0] = n!
// Nachbedingung II
return Z [0]
I nach Beenden der Schleife gilt:
Q
I
I
|Z | = 1
und
S := z∈Z z = n!
⇒ Nachbedingung gilt: Z [0] = n!
⇒ Algorithmus liefert korrektes Ergebnis
Teile-und-Herrsche-Paradigma
Problem
Teile-und-Herrsche-Paradigma
1. Teile das Problem
Problem
Teile-und-Herrsche-Paradigma
1. Teile das Problem
Problem
direkt lösbare Probleme
Teile-und-Herrsche-Paradigma
1. Teile das Problem
2. Beherrsche die Teilprobleme
Problem
direkt lösbare Probleme
Teile-und-Herrsche-Paradigma
1. Teile das Problem
2. Beherrsche die Teilprobleme
3. Verbinde die Teillösungen
Problem
direkt lösbare Probleme
Teile-und-Herrsche: Laufzeit
Function
recFunc(n :
N)
:
...
recFunc(n/2)
...
I Laufzeit durch Rekurssion nicht oensichtlich
I Drücke Rekurssion durch Formel aus
I Rekurrenzgleichungen
Teile-und-Herrsche: Laufzeit
Function
recFunc(n :
N)
:
...
recFunc(n/2)
...
I Laufzeit durch Rekurssion nicht oensichtlich
I Drücke Rekurssion durch Formel aus
I Rekurrenzgleichungen
I Bsp.
T (n)
Laufzeit von Algorithmus, der Problem immer
halbiert und nur eine Hälfte betrachtet:
T (n) = T (n/2) + Laufzeit
Teilen/Zusammensetzen
Karatsuba-Ofman Multiplikation
Function recMult(a, b)
assert a und b haben n Ziern, sei k = dn/2e
if n = 1 then return a · b
k
Schreibe a als a · B + a
// ai hat dn/2e Ziern
k
Schreibe b als b · B + b
// bi hat dn/2e Ziern
1
0
1
c
c
0
11 := recMult(a1 , b1 )
00
:= recMult(a0 , b0 )
return
c · B k+
(recMult((a + a ), (b + b )) − c − c )B k
+c
2
11
1
00
0
1
0
11
00
Karatsuba-Ofman, Beispiel
1242
· 3163
Karatsuba-Ofman, Beispiel
1242
· 3163
12
· 31 =
Karatsuba-Ofman, Beispiel
1242
· 3163
12
42
· 31 =
· 63 =
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 =
· 63 =
54 · 94 =
12
42
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 =
· 63 =
54 · 94 =
12
42
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 =
· 63 =
54 · 94 =
12
42
12
· 31
·3=
2·1 =
3·4 =
1
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 =
· 63 =
54 · 94 =
12
42
12
· 31
·3= 3
2·1 = 2
3 · 4 = 12
1
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 =
· 63 =
54 · 94 =
12
42
12
· 31
372
·3= 3
2·1 = 2
3 · 4 = 12
1
372
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 =
· 63 =
54 · 94 =
12
42
12
· 31
372
·3= 3
2·1 = 2
3 · 4 = 12
1
372
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 = 372
· 63 = 2646
54 · 94 =
12
42
12
· 31
372
·3= 3
2·1 = 2
3 · 4 = 12
1
42
· 63
2646
· 6 = 24
2·3 = 6
6 · 9 = 54
4
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 = 372
· 63 = 2646
54 · 94 =
12
42
12
· 31
372
·3= 3
2·1 = 2
3 · 4 = 12
1
42
· 63
2646
· 6 = 24
2·3 = 6
6 · 9 = 54
4
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 = 372
· 63 = 2646
54 · 94 =
12
42
12
· 31
372
·3= 3
2·1 = 2
3 · 4 = 12
1
42
· 63
2646
· 6 = 24
2·3 = 6
6 · 9 = 54
4
54
· 94
· 9=
4· 4 =
9 · 13 =
5
45
16
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 = 372
· 63 = 2646
54 · 94 =
12
42
12
· 31
372
·3= 3
2·1 = 2
3 · 4 = 12
1
42
· 63
2646
· 6 = 24
2·3 = 6
6 · 9 = 54
4
54
· 94
· 9=
4· 4 =
9 · 13 =
5
45
16
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 = 372
· 63 = 2646
54 · 94 =
12
42
12
· 31
372
·3= 3
2·1 = 2
3 · 4 = 12
1
42
· 63
2646
· 6 = 24
2·3 = 6
6 · 9 = 54
4
· 94
· 9 = 45
4 · 4 = 16
9 · 13 = 117
· 13
·1= 0
9 · 3 = 27
9 · 4 = 36
54
9
117
5
0
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 = 372
· 63 = 2646
54 · 94 = 5076
12
42
12
· 31
372
·3= 3
2·1 = 2
3 · 4 = 12
1
42
· 63
2646
· 6 = 24
2·3 = 6
6 · 9 = 54
4
54
· 94
5076
9
· 13
117
· 9 = 45
4 · 4 = 16
9 · 13 = 117
5
·1= 0
9 · 3 = 27
9 · 4 = 36
0
Karatsuba-Ofman, Beispiel
1242
· 3163
· 31 = 372
· 63 = 2646
54 · 94 = 5076
12
42
3928446
12
· 31
372
·3= 3
2·1 = 2
3 · 4 = 12
1
42
· 63
2646
· 6 = 24
2·3 = 6
6 · 9 = 54
4
54
· 94
5076
9
· 13
117
· 9 = 45
4 · 4 = 16
9 · 13 = 117
5
·1= 0
9 · 3 = 27
9 · 4 = 36
0
Karatsuba-Ofman, Laufzeit
I
n∈N
Länge der Eingabe
T (n)
Karatsuba-Ofman, Laufzeit
I
n∈N
Länge der Eingabe
(
T (n) ≤
1
falls
n=1
Karatsuba-Ofman, Laufzeit
I
n∈N
Länge der Eingabe
(
T (n) ≤
1
3
falls
· T (dn/2e) + 10n
falls
n=1
n>1
Karatsuba-Ofman, Laufzeit
I
n∈N
Länge der Eingabe
(
T (n) ≤
1
3
falls
· T (dn/2e) + 10n
I Rekurrenz/Rekursionsgleichung
falls
n=1
n>1
Karatsuba-Ofman, Laufzeit
I
n∈N
Länge der Eingabe
(
T (n) ≤
1
3
falls
· T (dn/2e) + 10n
falls
I Rekurrenz/Rekursionsgleichung
Laufzeit im
O-Kalkül?
n=1
n>1
Mastertheorem, einfache/gerundete Form
a, b , c , d
positive Konstanten und
n∈N
(
a
T (n) =
d · T (dn/be) + cn
für
für
n=1
n>1
Mastertheorem, einfache/gerundete Form
a, b , c , d
positive Konstanten und
n∈N
(
a
T (n) =
d · T (dn/be) + cn
für
für
n=1
n>1
Es gilt


Θ(n)
T (n) ∈ Θ(n log n)


Θ n bd
log
falls
falls
falls
d <b
d =b
d > b.
Mastertheorem, einfache/gerundete Form
a, b , c , d
positive Konstanten und
n∈N
(
a
T (n) =
d · T (dn/be) + cn
für
für
n=1
n>1
Es gilt


Θ(n)
T (n) ∈ Θ(n log n)


Θ n bd
log
falls
falls
falls
d <b
d =b
d > b.
I Karatsuba-Ofman:
T (n) ∈ Θ n
log2 3
Abschätzung von Rekurrenzen
(
T (n) =
1
2T (dn/3e)
falls
+ n + log n
falls
n=1
n>1
Abschätzung von Rekurrenzen
(
T (n) =
1
2T (dn/3e)
Master-Theorem anwendbar?
falls
+ n + log n
falls
n=1
n>1
Abschätzung von Rekurrenzen
(
T (n) =
1
falls
2T (dn/3e)
+ n + log n
falls
n=1
n>1
Master-Theorem anwendbar?
(
T (n) =
1
1
2T1 (dn/3e)
falls
+ n
falls
n=1
⇒ T (n) ∈ Θ(n)
n>1
1
Abschätzung von Rekurrenzen
(
T (n) =
1
falls
2T (dn/3e)
+ n + log n
falls
n=1
n>1
Master-Theorem anwendbar?
(
1
T (n) =
1
2T1 (dn/3e)
falls
+ n
(
T (n) =
2
1
2T2 (dn/3e)
falls
falls
+ 2n
falls
n=1
⇒ T (n) ∈ Θ(n)
n>1
1
n=1
⇒ T (n) ∈ Θ(n)
n>1
2
Abschätzung von Rekurrenzen
(
T (n) =
1
falls
2T (dn/3e)
+ n + log n
falls
n=1
n>1
Master-Theorem anwendbar?
(
1
T (n) =
1
falls
2T1 (dn/3e)
+ n
(
T (n) =
2
1
falls
falls
2T2 (dn/3e)
+ 2n
falls
∀n ∈ N : T (n) ≤ T (n) ≤ T (n)
1
2
n=1
⇒ T (n) ∈ Θ(n)
n>1
1
n=1
⇒ T (n) ∈ Θ(n)
n>1
2
⇒
T (n) ∈ Θ(n)
Abschätzung von Rekurrenzen
(
T (n) =
1
8T (dn/2e)
falls
+n
2
falls
n=1
n>1
Abschätzung von Rekurrenzen
(
T (n) =
1
8T (dn/2e)
Master-Theorem anwendbar?
falls
+n
2
falls
n=1
n>1
Abschätzung von Rekurrenzen
(
T (n) =
1
8T (dn/2e)
falls
+n
2
falls
n=1
n>1
Master-Theorem anwendbar? Nicht in einfacher Form!
Abschätzung von Rekurrenzen
(
T (n) =
1
8T (dn/2e)
falls
+n
2
falls
n=1
n>1
Master-Theorem anwendbar? Nicht in einfacher Form!
I nde/rate untere/obere Schranken
Abschätzung von Rekurrenzen
(
T (n) =
1
8T (dn/2e)
falls
+n
2
falls
n=1
n>1
Master-Theorem anwendbar? Nicht in einfacher Form!
I nde/rate untere/obere Schranken
I beweise Richtigkeit durch vollständige Induktion
Abschätzung von Rekurrenzen
(
T (n) =
1
falls
8T (dn/2e)
+n
2
falls
n=1
n>1
Master-Theorem anwendbar? Nicht in einfacher Form!
I nde/rate untere/obere Schranken
I beweise Richtigkeit durch vollständige Induktion
I im Beispiel:
∀k ∈ N , n = 2k : n ≤ T (n) ≤ 2n − n
3
0
3
2
Herunterladen