Algorithmen I

1 Web: Übungen: Peter Sanders Algorithmen I

April 17, 2009

Institut für theoretische Informatik, Algorithmik II

Robert Geisberger und Johannes Singler Sanders: Algorithmen I http://algo2.iti.uni-karlsruhe.de/AlgorithmenI.php 2

April 17, 2009 wöchentlich wöchentlich Einteilung mittels Webinscribe Ausgabe Mittwoch nach der Übung Abgabe Freitag 14 Uhr (9 Tage nach Ausgabe) Mi: 14:45–15:30 Mi: 14:00–14:45 Mo: 14:00–15:30 Organisatorisches Sanders: Algorithmen I Übungsblätter: Tutorium: Saalübung: Vorlesungen: 3

April 17, 2009 Peter Sanders, Dienstag 14–15 Uhr, Raum 217 ! Organisatorisches Sanders: Algorithmen I Sprechstunde: 4

April 17, 2009 Mo 8.6. 14:00–15:45, Audimax. 10% der Note 3.8.2009, 11:00–13:00. 90% der Note Organisatorisches Sanders: Algorithmen I Mittsemesterklausur: Abschlussklausur: 5 Toolbox Basic The — Structures

April 17, 2009 Data and Springer 2008 (Unterhaltung / Motivation) Algorithms Springer 2008, ggf. einzelne Kapitel der deutschen Übersetzung von Prof. Martin Dietzfelbinger. K. Mehlhorn, P. Sanders Taschenbuch der Algorithmen Buch: Folien, Übungsblätter ! ! ! Materialien Sanders: Algorithmen I 6 , ableitet: Namens Rechenvorschrift. ) aber lebte in geschrieben.

April 17, 2009 Khorasan . Landschaftsbezeichnung ? Kann man das essen? 840 wurde zum Synonym für .. war persischer/usbekischer 780 Rechenlehrbuch ≈ Algorithmus Machtzentrum des arabischen Kalifats auf seinem Höhepunkt. Er hat ein Das war damals “Elite” – Al-Khwarizmi Pseudogriechische Verballhornung eines Algorithmus Bagdad der sich aus einer " Wissenschaftler (aus Sanders: Algorithmen I 7 deﬁnierte . genau versteht man eine endlich vielen Schritten April 17, 2009 zur Lösung eines Problems oder einer bestimmten Algorithmus Handlungsvorschrift Art von Problemen in Unter einem Moderne Deﬁnition (Wikipedia): Sanders: Algorithmen I 8

praktische effiziente Soft− u. Hardware

April 17, 2009 Informatik Logik korrekte

Algorithmik theoretische mit direktem Anwendungsbezug Kerngebiet der (theoretischen) Informatik Algorithmik Sanders: Algorithmen I 9 haben, nennen ∞ Struktur ) 17 7 1113 5 interessante . Daten 57

April 17, 2009 . Basic Toolbox 3 11 13 17 2 3 19 2 19 Datenstruktur wichtiger Teil der Immer wiederkehrende Datenstrukturen und dazugehörige Algorithmenteile " wir das Wenn ein Teil dieser Daten eine ( Ein Algorithmus bearbeitet Datenstruktur Sanders: Algorithmen I 10 Pﬂichtvorlesung " neue Algorithmen Leistungsgarantien, objektiver " "

April 17, 2009 benötigte Algorithmenvergleich Entwurfstechniken Analysetechniken Datenstrukturen Algorithmen ! ! ! ! Jeder Informatiker braucht das Immer wieder Themenauswahl: Werkzeugkasten Sanders: Algorithmen I 11 Appetithäppchen immer gut verbunden schnellstens zum Ziel Efﬁzienz durch Ordnung Chaos als Ordnungsprinzip Beziehungen im Griff haben die eierlegende Wollmilchsau immer die Übersicht behalten globalen Dingen auf der Spur noch mehr Entwurfsmethoden Mütter und Väter aller Datenstrukturen der Werkzeugkasten für den Werkzeugkasten

April 17, 2009 8. Graphrepräsentation 9. Graphtraversierung 6. Prioritätslisten 7. Sortierte Liste 4. Hashing 5. Sortieren I 2. Einführung 3. Folgen, Felder, Listen 1. Amuse Geule Inhaltsübersicht 12. Optimierung 10. Kürzeste Wege 11. Minimale Spannbäume Sanders: Algorithmen I 12 . 1 − B .. 0 ∈ i a , ) 0 a ... 1 − n a j =( b · und i a a c + j := ) b p , + nfolgen $ i p a (

April 17, 2009 := Ziffer ) s , $ c ( Wir zählen Volladditionen Ziffernmultiplikationen Schreibe Zahlen als Beispiel: Langzahl-Multiplikation 1 Amuse Geule Sanders: Algorithmen I 13 carry / Überlauf // b c s a 0 Ziffern-Additionen. 0 n c + i b + i a := ) i s , c (

April 17, 2009 n -Ziffern-Zahlen braucht do n 1 − n to Digit : := 0 c i 0 := = n Satz: Addition von s for c 1.1 Addition Sanders: Algorithmen I 14 } ab = i 2: ≥ b , a ¬∃ on demand 2: Einrückung trägt Bedeutung ≥ i ,. . . { until ... begin/end − Menschenlesbarkeit vor Maschinenlesbarkeit c repeat + , Digit

April 17, 2009 i : b Mathe 0 + + i = a while c , // := := volle Mathepower ) i for s , c , Datentypen, Klassen, Speicherverwaltung Buch Abschnitt 2.3, hier: just in time und ( if Kein C/C++/Java Eher Pascal ! ! Exkurs: Pseudocode Sanders: Algorithmen I Deklarationen: Zuweisung: uvam: Schleifen: Tupel: Kommentar: Ausdrücke: 15 ) Digit : b , Digit of ] 1 − n low(ab) high(ab) c result .. 0 [ 0 0 Array : a (

April 17, 2009 n numberTimesDigit Function Ziffernmultiplikation Sanders: Algorithmen I 16 ) Digit : b Additionen , n 1 Iterationen kein Überlauf?! = Digit , − Ziffernaddition 1 carry / Überlauf n of // ] // // 1 )+ 1 Ziffernmultiplikation Ziffernmultiplikation − − n // // n .. ( 0 [ Ziffernaddition // Array ! : + a $ ( Digit h Multiplikationen, + of ] n do c n b 1 .. ·

April 17, 2009 $ := 0 ] h )= [ i − b ]) [ i 1 · n [ a + ] − 0 ! c [ to := n h a ) := := result result ] ] Array Digit ,! , numberTimesDigit := +( := 0 n : $ : c h := 1 [ [ ) 1 ( h ( i 0 ,! $ = h result result return for c result ( Function Analyse: Ziffernmultiplikation Sanders: Algorithmen I 17 Langzahl n−1 0 // b p a Schieben: aB , 2 0 aB Ziffer n−1 aB n n j

April 17, 2009 B · do ] j 1 [ b − · n a + to p 2n−1 N Langzahladdition, Langzahl mal : := := 0 p j // 0 = p for 1.2 Schulmultiplikation Sanders: Algorithmen I 18 0) = j Ziffern (außer bei j + Additionen/Multiplikationen n n 1 Ziffernadditionen (optimiert) // je + Additionen schieben (keine Ziffernarithmetik) n // 1 // // − 2 n 2

April 17, 2009 )= do 1 1 Ziffernoperationen + ] − j 2 n n [ n )( b j 3 · 1 to B p a · + ≤ − N 1 n : := := 0 p − i 0 Multiplikationen +( 2 = n 2 2 p 3 for Insgesamt: n n Schultmultiplikation Analyse Sanders: Algorithmen I 19 } ? ) n ( f · c ≤ ) welche Ops.? n ( g : 0 n " ≥ 2 n n ! ∀ : O + N Zeit ∈ 0 n ∃ Laufzeit 0: " > c Information weg April 17, 2009 ∃ : ) vereinfachen n zuviel ( g { = )) n ( Interpretation vereinfachen Rechnungen Werfen wir Operationen zählen f ( ? + + + Beispiel: Schulmultiplikation braucht O Exkurs O-Kalkül, die Erste Idee: Konstante Faktoren (und Anfangsstück) ausblenden Sanders: Algorithmen I 20

April 17, 2009 später an Beispielen 1.3 Ergebnisüberprüfung Sanders: Algorithmen I 21 k ist Zweierpotenz B n )) 0 b , 1 a Ziffern, ( k 2 b 0 0 + · = a b k 2 recMult a n + + B ) + k k · ) 0 B B ) 1 ) b · · 1 , b b

April 17, 2009 b , , 0 1 1 haben , 0 a a a b 1 ( ( a b a ( ( als als und a b then return a 1 recMult recMult recMult ( + recMult = n Schreibe Schreibe return if assert Function 1.4 Ein rekursiver Algorithmus Sanders: Algorithmen I 22 Ops Ops Ops Ops 1 Op ) n n n 0 Ops 0 Ops n 2 2 2 // ( // // T )+ )+ )+ // 2 2 2 / / / n n n ( ( ( T T T 2 // // // k ist Zweierpotenz B n )) 0 b , 1 a Ziffern, ( k Ops sparen? 2 n b 0 0 + · 2 = a b k 2 recMult a n n + + ≈ B 6 ) + k k · ) 0 B B ) 1 ) b · · 1 )+ , b b

April 17, 2009 b , , 0 1 1 2 haben , 0 a a a b / 1 ( ( a b n ( a ( ( als als T und a b 4 then return a 1 recMult recMult ≤ recMult ) ( + recMult = n ( n T return if assert Schreibe Schreibe Übung: Wo kann man hier Function Also Analyse Sanders: Algorithmen I 23 . , 2 1 ≥ = n n if if n · 6 " 2 )+ n * ! 2 / O n ) ( = T · " 1 4 4 2   

April 17, 2009 ≤ log ) n n n ( 6 ! T − Θ 2 n 7 eine Zweierpotenz ist )= ≤ n (Master-Theorem, stay tuned) ) n n ( ( T −→ , falls Zeigen Sie durch vollständige Induktion, dass T Aufgabe: Analyse Sanders: Algorithmen I 24 Teilprobleme, kleinere

April 17, 2009 (lat. divide et impera, engl. divide and conquer) z. B. Ziffernmultiplikation, Addition z. B. Addition Aufteilen in eins oder mehrere, oft rekursiv Im Buch: siehe auch Index! Exkurs: Algorithmen-Entwurfsmuster Metaheuristiken, Randomisierung,. . . Es kommen noch mehr: greedy, dynamische Programmierung, Sanders: Algorithmen I Teile und Herrsche: Schleife: Unterprogramm: 25 1 b 0 a + 0 b k 1 [1962] B a ) + 00 c 0 b − 0 a ist Zweierpotenz 11 c + n 1 − b 1 )) a 0 b Ziffern, + )= k 0 1 2 b b b 0 0 ( · = a b , + a ) n 1 + + 0 b ) ) k k a 1 0 B B )( ) b b + · · 0 b , ,

April 17, 2009 , a 1 1 1 1 0 haben a a a b a a ( + b ( ( + (( 1 k als als 2 a ( und a b B then return · 00 a 1 recMult c recMult recMult 11 recMult + c ( = := := n 00 11 c c Schreibe Schreibe return assert if Beobachtung: Function 1.5 Karatsuba-Ofman Multiplikation Sanders: Algorithmen I 26 . , 2 1 ≥ = n n if if n " · 58 10 . 1 n )+ * ! 2 / Θ n ) ( ≈ T · " 3 1 3 2   

April 17, 2009 log ≤ ) n n ! ( T Θ )= (Master-Theorem) n ( T −→ Analyse Sanders: Algorithmen I 27 $

experiment design implement

Algorithmics analyze

April 17, 2009 was hat das mit der Praxis zu tun? Mehr: DFG Schwerpunktprogram www.algorithm-engineering.de 1.6 Algorithm Engineering – Sanders: Algorithmen I 28 applications implementation

April 17, 2009 deduction Theory Practice analysis design models perf. guarantees Algorithmentheorie (Karikatur) Sanders: Algorithmen I 29

7 Anwendungen reale Eingaben 6 5 1 2 4 Entwurf Induktion realistische Modelle bibliotheken Algorithmen− Hypothesen falsifizierbare

April 17, 2009 Implementierung 3 Analyse Experimente Deduktion Algorithm Engineering garantien Leistungs− Algorithmik als Algorithm Engineering Sanders: Algorithmen I 30 1024 512 256 128 64 32 recursion threshold Karatsuba, n = 4096 Karatsuba, n = 2048 16 8 4 0.1 0.4 0.3 0.2

April 17, 2009 Hardware-Fähigkeiten ↔ z. B. 32 Bit Assembler, SIMD,. . . Schulmultiplikation für kleine Eingaben Zifferngröße ! ! ! Zurück zur Langzahlmultiplikation Sanders: Algorithmen I 31 14 2 12 2 10 2 n 8 2 Karatsuba4 6 Karatsuba32 2 school method school 4 2 1 10 0.1 0.01

0.001 1e-05

0.0001 time [sec] time

April 17, 2009 Implementierungsdetail setzt sich durch Konstante Faktoren oft Asymptotik ! ! Skalierung Sanders: Algorithmen I 32 ) n n aus 1 ≤ loglog n n log falls sonst n ( n O n log -Bit Zahlen log mehr Teile ∗ ) n n ) n log ∗ log + ( log 1 0 ( O O    2 : Bitkomplexität = n ∗ log

April 17, 2009 : Bitkomplexität Multiplikationen von ) n ( Kryptographie O der " Praxis: Karatsuba-Multiplikation ist nützlich für Zahlenlänge Bessere Potenzen durch Aufspalten in Schnelle Fourier Transformation [Schönhage-Strassen 1971] [Fürer 2007] ! ! ! ! ! Iterierter Logarithmus: Blick über den Tellerrand Sanders: Algorithmen I 33

April 17, 2009 2 Einführendes Sanders: Algorithmen I 34

April 17, 2009 Graphen Codeannotationen Mehr Algorithmenanalyse Maschinenmodell Pseudocode Algorithmenanalyse ! ! ! ! ! ! 2.1 Überblick Sanders: Algorithmen I 35 (!) I r) ) I ( T n = | I | T(n) alle Eingaben max = ) n ( T Worst case: (# Takte), eigentlich für ) I

April 17, 2009 ( Instanzen mit |I|=n T Ein Programm Laufzeit (oder auch Speicherverbrauch, Energieverbrauch,. . . ) Erste Vereinfachung: Gegeben: Gesucht: 2.2 (Asymptotische) Algorithmenanalyse (Später mehr: average case, best case, die Rolle des Zufalls, mehr Paramete Sanders: Algorithmen I 36 } } } } ) ) ) ) n n n n ( ( ( ( f f f f · · · · c c c c ≤ ≥ ≤ ≥ ) ) ) ) n n n n ( ( ( ( g g g g : : : : 0 0 0 0 n n n n ≥ ≥ ≥ ≥ n n n n ∀ ∀ ∀ ∀ : : : : + + + + N N N N ∈ ∈ ∈ ∈ 0 0 0 0 )) n n n n n ∃ ∃ ∃ ∃ ( f 0: 0: 0: 0: ( Ω > > > > c c c c ∩

April 17, 2009 ∀ ∃ ∃ ∀ )) : : : : n ) ) ) ) ( n n n n f ( ( ( ( ( g g g g { { O { { „genau“ = = = = = „weniger“ „mehr“ „mindestens“ „höchstens“ )) )) )) )) )) n n n n n ( ( ( ( ( f f f f f ( ( ( ( ( o O Θ ω Ω Zweite Vereinfachung: Asymptotik Sanders: Algorithmen I 37 c , )) n ( f ( O )= n ( . g )) n ( für jede positive Konstante falls , g · )) ’ )) ) )) n n n n ) E ( ( ( ( k f f f f n ⊆ ( ( ( ( ( } O O Ω O Θ ) n = ( i f )= )= )= n )) = n n n

April 17, 2009 { i ( ( n ( a ( g g 0 g cf k ( = ∑ i ’ als ‘ )+ )+ O E · n n ( ( f f )) )= n ( n f ( f ( O u. s. w. Schludrigkeit: implizite Mengenklammern. Lese ‘ O-Kalkül Rechenregeln Sanders: Algorithmen I 38 +−*/&v~ <>= 2 ... k Program Control Program R1 (log Space) Θ [von Neumann 1945] load store

April 17, 2009 ... 2 S1 RAM (Random Access Machine) von Neumann-Modells Moderne (RISC) Adaption des 2.3 Maschinenmodell: Sanders: Algorithmen I 39 +−*/&v~+−*/&v~ <>= 22 ...... kk Program Control Control Program Program R1 R1 (log Space) ΘΘ loadload storestore

April 17, 2009 ...... 22 für S1 S1 k R ,. . . , (irgendeine Konstante) Speicher 1 k R (kleine) ganze Zahlen Register Sanders: Algorithmen I 40 +−*/&v~ <>= 2 ... k Program Control Program R1 (log Space) Θ load store

April 17, 2009 ... 2 für S1 ... ] 2 [ S , ] 1 [ (kleine) ganze Zahlen Unbegrenzter Vorrat an Speicherzellen S Hauptspeicher Sanders: Algorithmen I 41 . i R . ] j R [ S in Register +−*/&v~ ] j <>= R [ S in Speicherzelle 2 ... k i Program Control Program R R1 (log Speicher) Θ load store

April 17, 2009 Register Inhalt von Speicherzelle ... 2 lädt speichert S1 i ] j R R [ := S ] j := R i [ Speicherzugriff Sanders: Algorithmen I S R 42 +−*/&v~ <>= 2 ... k Program Control Program R1 (log Space) Θ load store

April 17, 2009 ... 2 Registerarithmetik. ! S1 R 0 ’ ist Platzhalter für eine Vielzahl von Operationen j 0 R Arithmetik, Vergleich, Logik ‘ := i Rechnen Sanders: Algorithmen I R 43 0 = i R fort falls j +−*/&v~ <>= 2 ... k Program Control Program R1 (log Space) Θ load store

April 17, 2009 ... 2 S1 Setze Programmausführung an Stelle i R , j Bedingte Sprünge Sanders: Algorithmen I JZ 44 bester -maliges Quadrieren führt zu einer n endlicher Automat " theoretisch unbefriedigend, weil nur endlich . Beispiel: viel zu optimistisch für vernünftige

April 17, 2009 Bits. n 2 ≈ Zahl mit Kompromiss. OK für Berechenbarkeit Komplexitätstheorie viel Speicher adressierbar Alternativen: „Kleine“ ganze Zahlen? Sanders: Algorithmen I Genug um alle benutzten Speicherstellen zu adressieren: Beliebige Genauigkeit: Konstant viele Bits (64?): 45 gerechtfertigt! ) · ( O

April 17, 2009 Abhängigkeit von Speicherverwaltungsalgorithmen? letzte belegte Speicherzelle? Anzahl benutzter Speicherzellen? Etwas unklar: Ausgeführte Befehle zählen, Nur durch späteres d. h. Annahme 1 Takt pro Befehl. Ignoriert Cache, Pipeline, Parallelismus. . . Hier: Es kommt eigentlich nie drauf an. ! ! ! Algorithmenanalyse im RAM-Modell Sanders: Algorithmen I Platz: Zeit: 46

April 17, 2009 Mehrere Prozessoren Zugriff Größe Zugriff auf konsekutive Speicherbereiche sind schnell kürzlich/häuﬁg zugegriffene Daten sind eher im Cache unabhängige Aufgaben identiﬁzieren " " blockweiser begrenzte schneller Zwischenspeicher " ! ! mehr in TI, Algorithmen II, Programmierparadigmen,. . . Mehr Maschinenmodell Sanders: Algorithmen I ··· Parallelverarbeitung: Cache: 47 2 ... k Program Control Program Netzwerk R1

April 17, 2009 Caches ... 2 S1 Mehr Maschinenmodell Sanders: Algorithmen I 48 2 i + ) i 2 . $ r c √ + Complex i Number , r ): . of $ c ) return + r ( Complex : Element $

April 17, 2009 Number : c : ( y , x Complex y x ( abs add := := r i return Complex Function Function Number Number Class Beispiel just in time 2.4 Pseudocode Sanders: Algorithmen I 49 gilt vor / nach jedem Aufruf einer Operation auf

April 17, 2009 gilt vor / nach jeder Ausführung des als zentrales Werkzeug für Algorithmenentwurf und Leistungsgarantie einer Prozedur, Bedingung für korrektes Funktionieren einer Prozedur Aussage, die an „vielen“ Stellen im Programm gilt Aussage über Zustand der Programmausführung Invarianten abstraktem Datentyp Schleifenkörpers falls Vorbedingung erfüllt Hier: Korrektheitsbeweis. 2.5 Design by Contract / Schleifeninvarianten Sanders: Algorithmen I Datenstrukturinvariante: Schleifeninvariante: invariant: Nachbedingung: assert: Vorbedingung: 50 0 n (*) a = r n p // Vorbedingung Nachbedingung // −→ 0 Schleifeninvariante = ) // n 0 p ∧ · = r 0 n // (*) := R ) N ∧ r p : ; 0 ): · 0 0 n p N = n , a : = −− a 2 n 0 ( n / = n ¬ n r ; ; ( n R April 17, 2009 R p : := then and 0 (Ein anderes als im Buch) ) n a do 1: 0 p ( a = , 0 r ≥ n = ( > 0 is odd ; r r n n n power R : if else invariant a = p return assert while assert Function 2.6 Beispiel Sanders: Algorithmen I 51 0 n (*) a = r r n p pr ()&' neues // ) n 1 Vorbedingung − '( Nachbedingung // neues n & p −→ = 0 r Schleifeninvariante n = p ) // n 0 p ∧ · = r 0 n // (*) := R ) N ∧ r p : ; 0 ): · 0 0 n p N = n , a : = −− a 2 n 0 ( n / = n ¬ n r ; ; ( n R April 17, 2009 R p : := then and 0 ) n a do 1: 0 p ( a = , 0 r ≥ n = ( > 0 is odd ; r r n n n power R : if else invariant a ungerade: Invariante erhalten wegen = p return assert while assert n Function Fall Beispiel Sanders: Algorithmen I 52 0 n (*) a = r n p n // 2 / Vorbedingung n neues &'() Nachbedingung ) // ' p p · )& −→ p neues ( 0 Schleifeninvariante =( = ) // n n 0 p p ∧ · = r 0 n // (*) := R ) N ∧ r p : ; 0 ): · 0 0 n p N = n , a : = −− a 2 n 0 ( n / = n ¬ n r ; ; ( n R April 17, 2009 R p : := then and 0 ) n a do 1: 0 p ( a = , 0 r ≥ n = ( > 0 is odd ; r r n n n power R : if else invariant a gerade: Invariante erhalten wegen = p return assert while assert n Function Fall Beispiel Sanders: Algorithmen I 53 . ))) $ I ( T , ) I )) ( T ( max -te Iteration )+ i ( Maschinenbefehle C ( T i T ( ∑ ( O O . ) $ I )= $ ( )= I T −→ &'() C

April 17, 2009 Übersetzungsregeln else )+ I I ( until T I einfache Rekurrenzrelationen then )= " -Notation vereinfacht die direkte Analyse des Pseudocodes. $ ) C I · ; ( I if repeat ( ( ( O T T T ! ! ! Rekursion Idee: Pseudo-Code Die fundamentalistische Sicht: Ausgeführte RAM-Befehle zählen 2.7 Programmanalyse Sanders: Algorithmen I 54 Summen ausrechnen "

April 17, 2009 Das lernen Sie in Mathe Beispiel: Schulmultiplikation 2.7.1 Schleifenanalyse Sanders: Algorithmen I 55 . N ∈ 1 2 k k für ein Basisfall teile und herrsche. k d 1 1 b = > = ...... n n n n falls falls , sei cn d , ) c b , / b n , ( a dr

April 17, 2009 + ...... n/b n/b n/b cn a 1 1a 1 a 1 a a 1 1 a a 12    = ) n ( r Für positive Konstanten 2.7.2 Eine Rekurrenz für Teile und Herrsche Sanders: Algorithmen I 56 . N ∈ k für ein Basisfall teile und herrsche. k 1 1 b . b b b = > = n n n < = > d d d falls falls , sei d falls falls falls , ) c b , / ) " b n n d , ( (Einfache Form) b a dr log log ) April 17, 2009 n n n + ( ! ( cn a Θ Θ Θ           = ) )= n n ( ( r r Es gilt Für positive Konstanten Master Theorem Sanders: Algorithmen I 57 0 i k level d ...... i − k b n cn = i b / n ...... n/b n/b n/b 1 1a 1 a 1 a a 1 1 a a 12 Probleme @ i d i

April 17, 2009 , b d + cn , haben wir i = i n b · c k · i d ad cn cost Auf Ebene Beweisskizze Sanders: Algorithmen I 58 ) n ( Θ = i ' , ) b d 1 ( )& + O 1 0 − = ∑ i k ( · cn b + < k ' ) d n ( d · )& o ( a

April 17, 2009 )= n ( r Rekursionsebene kostet konstanten Teil der Arbeit erste d=2, b=4 Beweisskizze Fall geometrisch schrumpfende Reihe −→ Sanders: Algorithmen I 59 ) n log n ( Θ = Ebenen. n ) b n ( b log b log cn = + = k d an

April 17, 2009 allen )= n ( r d=b=2 Beweisskizze Fall gleich viel Arbeit auf Sanders: Algorithmen I 60 d b log n = . d d b b log log k n b - Θ = b d = i log log k , b b d = + 1 0 d − = ∑ i k log b · b b log log cn > k + 2 d k =

April 17, 2009 ad d log k )= 2 n ( r = Rekursionsebene kostet konstanten Teil der Arbeit k d letzte d=3, b=2 Beweisskizze Fall beachte: geometrisch wachsende Reihe −→ Sanders: Algorithmen I 61 . N ∈ k für ein Basisfall teile und herrsche. k 1 1 b = > = n n n falls falls , sei d , ) allgemeinerer Fall c b , / b n , ( a dr

April 17, 2009 + quicksort cn a , kommt noch,    = ) n ( mergesort, Schulmultiplikation, Karatsuba-Ofman-Multiplikation Median bestimmen r : : : b b b > < = schon gesehen Für positive Konstanten Master Theorem Beispiele Sanders: Algorithmen I d d d 62

April 17, 2009 später an Beispielen 2.9 Randomisierte Algorithmen später an Beispielen 2.8 Analyse im Mittel Sanders: Algorithmen I 63 3,3 5 K K x u s t wv U u u undirected bidirected wv wv , Knoten, Kanten, (un)gerichtete t u 1 2 2 x y 1 Relationen

April 17, 2009 1 G 1 1 1 z w 1 1 2−2 s v w 1 v self−loop H knoteninduzierte Teilgraphen. Pfade (einfach, Hamilton-), Kreise, DAGs Graphen, Kantengewichte, Knotengrade, Kantengewichte, Sie kennen schon (?): 2.10 Graphen Sanders: Algorithmen I 64 / 2b + a v r t rooted su v directed expression r t su v

April 17, 2009 r t su undirected rooted undirected v t r u s undirected Zusammenhang, Bäume, Wurzeln, Wälder, Kinder, Eltern, . . . Bäume Sanders: Algorithmen I 65 in do ) 0 } v an (Kapitel 8), geht aber in { )= × v ( V )) ∪ E , V V × is a DAG iff the input graph is a DAG

April 17, 2009 } =( outdegree } G Repräsentation v : v { G { ( ( V \ \ ∈ E . V v ) |V|=0 | ∃ isDAG := := E | (directed acyclic graph, gerichteter azyklischer Graph) ist e invariant E V + | return while DAG V | ( Function Analyse: kommt auf O Ein Ein erster Graphalgorithmus gerichteter Graph, der keine Kreise enthält. Sanders: Algorithmen I 66 bei polynomiell ). ) 1 ( O n

April 17, 2009 denen es SEHR überraschend wäre, wenn sielösbar in wären. Polynomialzeit gleichzusetzen (d. h. Laufzeit Es gibt viele algorithmische Probleme (NP-vollständig/hart), Es gibt einigermaßen gute Gründe, efﬁzient mit ! ! Ganz kurz: das kommt in "Grundlagen der theoretischen Informatik" 2.11 P und NP Sanders: Algorithmen I 67

April 17, 2009 3 Folgen als Felder und Listen Sanders: Algorithmen I 68 Mathe Algorithmik Softwaretechnik 6 ,... 11 , 9 , 7 , 5 , Datei, Stapel, Zeichenkette, Log. . . , 3 , Liste 2 5 April 17, 2009 (stack, . . . ) Begriff , Schlange, Feld Repräsentation Funktionalität abstrakter ! ! ! Wir unterscheiden: (sequence, array, queue, list, ﬁle, stack, string, log. . . ). Folge, spielen in der Informatik eine überragende Rolle. Das sieht man schon an der Vielzahl von Begriffen: Folgen Sanders: Algorithmen I 69 Graph

April 17, 2009 (Kapitel 8),. . . Ablegen und Bearbeiten von Daten aller Art Konkrete Repräsentation abstrakterer Konzepte wie Menge, ! ! Anwendungen Sanders: Algorithmen I 70 ’ ∗ inter-list splice cache-efﬁcient not with insertAfter only removeAfter only amortized amortized amortized amortized explanation ‘ ∗ ∗ ∗ ∗ ∗ 1 1 n 1 1 CArray ∗ ∗ ∗ 11 n n nn nn 11 nn nn 1 UArray ∗ ∗ ∗ n 1

April 17, 2009 SList ∗ nn n n n 11 11 11 111 111 1 111 11 1 1 1 1 1 1 1 List | ] · · ﬁrst splice ﬁndNext,. . . last insert [ | concat pushFront popBack popFront remove pushBack Operation Form Follows Function Sanders: Algorithmen I 71

April 17, 2009 3.1.1 Doppelt verkettete Listen 3.1 Verkettete Listen Sanders: Algorithmen I 72 - - this - = next → one link in a doubly linked list prev // Item = Listenelements? prev Listenelements?

April 17, 2009 // → Pointer to next Element of Handle Handle : : Element Handle = Item : prev invariant next e Nachfolger des letzten Problem: Vorgänger des ersten Class Class Listenglieder (Items) Sanders: Algorithmen I 73 ··· - ··· - Sonderfälle

April 17, 2009 immer erfüllt ⊥ schnell testbar elegant einfach lesbar - Vermeidung vieler Invariante Speicherplatz (irrelevant bei langen Listen) " " " " " − + + Trick: dummy header Sanders: Algorithmen I 74 ? 56 ⊥ // - .next .prev h h Pos. before any proper element // h this return return .next = h isEmpty; isEmpty; ¬ ¬ init to empty sequence // return ; return address of } assert assert 1 , 0 { : Handle;

April 17, 2009 Handle; : Handle; Item : : : isEmpty ﬁrst last head , is the predecessor of the ﬁrst element Element h ⊥ of this this + Simple access functions List Item and the successor of the last element. = . . . Function Function Function Function // // h // Class Die Listenklasse Sanders: Algorithmen I t 75 - - - - - $ $ R R - - - R - and insert after 6 b ··· ··· ··· ··· ··· ,..., - - - - - ··· ··· ··· ··· ··· a 5 6 a b b b - - Y Y Y ,..., Cut out a $ t a b t a // ) 8∈ 5 t t ∧ // // // // // // // a Handle : 6 after b 6

April 17, 2009 b a,b,t $ $ ( ,..., a b $ b a t t a ,..., 5 := := prev next a := := := := next 5 splice b is not before → → → a b t next prev prev next next prev := := → → := → insert Cut out → $ $ $ → $ → $ $ assert a b // // a b a b t t t Procedure Sanders: Algorithmen I 76 ) 6 ) ,... head ) last $ $ , , c a b b , , ( ( b b , , $ b a ( ..., c moveAfter moveAfter , ) a ) ..., Handle) splice Handle Handle : : : $ 6 9→ 5 b b a ( ( , b ,... $

April 17, 2009 c , $ a ..., moveToFront moveToBack moveAfter( c , b , a ..., Moving elements around within a sequence. 5 Procedure Procedure Procedure // // Der Rest sind Einzeiler (?) Sanders: Algorithmen I 77 be,. . . ) member in Java) static

April 17, 2009 stellt sicher, dass die nicht leer ist. enthält ungenutzte Items. insgesamt braucht anwendungsspeziﬁsch, z. B. wenn man weiß wieviele Items man verfeinerte Freelistkonzepte (klassenübergreifend, Freiga naiv aber mit guter Speicherverwaltung potentiell sehr langsam ! ! ! freeList checkFreeList Reale Implementierungen: " Hier: einmal existierende Variable (z. B. naiv / blauäugig /optimistisch: Speicherverwaltung der Programmiersprache Oder doch nicht? Speicherverwaltung! Sanders: Algorithmen I 78 ) , freeList.head b ( 6 ) ) moveAfter ) ,... ﬁrst last c ( ( , a Handle ..., :

April 17, 2009 b ( 6 9→ 5 ,... popBack remove remove popFront remove c , b , a ..., 5 Procedure Procedure Procedure // Items löschen Sanders: Algorithmen I 79 , x to hold $ a is nonempty. Handle , head) , last) Handle freeList x x ): ): put it at the right place. // Obtain an item Handle : Handle // : insertAfter( b insertAfter( make sure and ﬁll it with the right content. ) 6 a ) // // ,... prev) b , → e Element; Element Element , b : Element; : : a , : x x e x ( ( ( x

April 17, 2009 ( ..., ) a , first $ . a 6 9→ 5 x ( $ pushFront pushBack insertAfter( a := insertBefore insertAfter ,... e b freeList , a → := $ $ return return a a checkFreeList moveAfter ..., 5 Function Procedure Procedure Function // Elemente einfügen Sanders: Algorithmen I ⊥ 80 - 9→ ··· ) 56 - ··· , 6 d ,..., - c , b ⊥ ,..., - a 5 // ( ) – unabhängig von der Listenlänge! 9→ ) List ) : 6 $ d April 17, 2009 .last, last) L $ this ( L ,..., c 5 .first, , makeEmpty concat $ 6 konstanter Zeit L 6 9→ 56 b b ,..., splice( freeList.concat( ,..., a a 5 5 ( Procedure Procedure // // Ganze (Teil)Listen Manipulieren Das geht in Sanders: Algorithmen I 81 ··· - ··· Handle fängt Sonderfälle ab. ): - Handle : x - do next x Element; from : 8= → April 17, 2009 x e ( Sentinel → from // Wächter-Element (engl. Sentinel) := from from findNext x from = e . return while h einfacher, schneller,. . . Function Allgemein: ein Spart Sonderfallbehandlung. Trick: gesuchtes Element in Dummy-Item schreiben: Suchen " Sanders: Algorithmen I 82 . size Effizienz geht nicht mehr in konstanter Zeit

April 17, 2009 ↔ splice Die Moral von der Geschicht: Es gibt nicht DIE Listenimplementierung. Problem: inter-list Funktionalität Verwalte zusätzliches Member Beispiel: Listenlängen Sanders: Algorithmen I 83 ...

April 17, 2009 eingeschränkter, z. B. kein remove merkwürdige Benutzerschnittstelle, z. B. removeAfter Platz ist oft auch Zeit weniger Speicherplatz ! ! ! ! Vergleich mit doppelt verketteten Listen 3.1.2 Einfach verkettete Listen Sanders: Algorithmen I 84 mit } ) ... E . Wohl deﬁniert obwohl nicht , 1 next → Item )= u u ( =( = G v G ,

April 17, 2009 Item indegree ∈ : u : ) v Item , u ∈ ( next zeigt immer auf ein Item u . { unbedingt leicht zu testen. u ∀ = ! ! Folge: Items bilden Kollektion von Kreisen E Betrachte den Graphen Einfach verkettete Listen – Invariante? Sanders: Algorithmen I 85 - - $ $ 9→ j - z - ) ) 6 6 splice ,... ,... 0 $ $ ) t t , , t b next next next ..., ··· → → 5 → ,..., $ , SHandle t b a 6 a : , - t / ... $ ,b,t April 17, 2009 $ b := ..., a , 5 ( a b b b , 0 6 ... - 3 next splice ,..., $ next next a b , , → $ $ → → $ a a $ t tt b a a / ..., ..., 5 5 ( ( // // Einfach verkettete Listen – Procedure Sanders: Algorithmen I 86 pushBack ... pushBack erlaubt Operation

April 17, 2009 Zeiger auf letztes Item Einfach verkettete Listen – Sanders: Algorithmen I 87 dynamische sind Schlüssel zu einfachen, machen Programme, einfacher, ,. . . erlauben Einsparung von ermöglichen ﬂexible, Wächter ,

April 17, 2009 Items Sonderfällen Datenstrukturinvarianten zwischen lesbarer, testbarer und schneller Sonderfällen efﬁzienten Datenstrukturen später: Bäume, Prioritätslisten Datenstrukturen Einsparung von Dummy-Elemente (einfache) Zeiger ! ! ! ! Listen: Zusammenfassung, Verallgemeinerungen Sanders: Algorithmen I 88 , , 6 6 1 e , − n n + e e ,..., ,..., 0 0 . e e 5 5 n " " )= 6 (e) 1 − n e 6 n popBack . a 6 n ,..., pushBack e . 0 6 e ,..., n 5 1

April 17, 2009 e ( a ,..., 5 0 e size = 5 ,..., 0 A e 5 falls i a = ] i [ A 3.2 Unbeschränkte Felder (Unbounded Arrays) Adressrechnung Größe muss von Anfang an bekannt sein Beschränkte Felder (Bounded Arrays) Eingebaute Datenstruktur: Ein Stück Hauptspeicher Felder (Arrays) Sanders: Algorithmen I 89

April 17, 2009 später: Stacks, Queues, Prioritätslisten, . . . Datei zeilenweise einlesen ! ! Beispiele: wenn man nicht weiß, wie lang das Feld wird. Unbeschränke Felder – Anwendungen Sanders: Algorithmen I 90 ++

April 17, 2009 Geht es schneller? " 2 n ! O −− Element anhängen, size )= size i 1 = n i Zuviel Platz?: umkopieren und (kleiner) neu anlegen Kein Platz?: umkopieren und (größer) neu anlegen ∑ pushBack Operationen brauchen Zeit ( O Immer passender Platzverbrauch? n wie beschränkte Felder: Ein Stück Hauptspeicher Unbeschränke Felder – Grundidee Sanders: Algorithmen I popBack: pushBack: 91 current size. allocated size // // 2 ≤ w w and 0 n = ··· n Element or n n of return 1 α ] n − Element 1 n < : < e − N ] April 17, 2009 i w : ] N w i [ ≤ : .. ≤ ··· Element b i 0 0 [ n [ size of 0 e N N assert return → Array 1: 0: UArray : b = = Function // Operator invariant w n b Class mit teilweise ungenutztem Speicher Unbeschränke Felder Sanders: Algorithmen I 92 3 3 3 4: 8: 2 2 2 = = $ w 1 1 1 w = e e 0 0 0 4, n 3 3 3 3 3 = → → → b b b 2 2 2 2 2 w // // // 1 1 1 1 1 0 0 0 0 0 → → → → → → $ $ Example for b b b b b b // // // // // // Example for // ) Element ) of N ]) ] Element : := 1 1 : $ ]) e w − − 1 ( ) ( pointer assignment $ n April 17, 2009 n [ w − // 2 b .. ( n [ 0 $ [ b ,..., then b ] reallocate pushBack 0 e w [ $ ,..., $ b ] allocate w ( Array reallocate b = := 0 ] [ $ n n := := $ := [ ++ b b dispose ( b n if b w Procedure Procedure Sanders: Algorithmen I 93 16: = w 5, 3 = 2 n 1 0 reduce waste of space → // b // Example for 4 4 // 3 3 2 2 1 1 0 0 then → → ) 0 b b

April 17, 2009 n 2 // // > ( n 0 ∧ > w popBack n ≤ reallocate n 4 −− n if assert Was geht schief, wenn man auf passende Größe kürzt? Procedure Kürzen Sanders: Algorithmen I 94 . ) 1 ( u O konstante Ausführungszeit = 6 m  

σ m ,..., ()&' 1 amortisiert

σ Gesamtzeit Operationen auf 5 / = m

σ #Ops &'()

April 17, 2009   popBack O ausgeführt. ) oder m ( O Zeit ein anfangs leeres, unbeschränktes Feld. pushBack u von Jede Operationenfolge — Sprechweise: pushBack und popBack haben Sei 3.2.1 Amortisierte Komplexität unbeschr. Felder wird in Sanders: Algorithmen I 95 Typ einzahlen abheben einzahlen ) ) ) Token Token Token n (1 (2 (

April 17, 2009 ×◦ ◦ n Kosten ◦◦ ) n 2 ( popBack pushBack Operation reallocate Erster Aufruf von reallocate: kein Problem Zu zeigen: keine Überziehungen Beweis: Konto-Methode (oder Versicherung) Sanders: Algorithmen I 96 ) n ) ( n 4 ( Typ einzahlen abheben einzahlen ) ) ) reallocate ' reallocate Token Token Token ' n ×◦ (1 (2 ( 2 popBack / )& " × n 2 ×◦◦ ≥ / )& " n pushBack n ≥ × ( April 17, 2009 ≥ n ×◦ ) ≥ ( ◦ n Kosten ◦◦ n ) 2 n ( 2 ) ( n 2 ( reallocate reallocate popBack pushBack Operation reallocate Weitere Aufrufe von reallocate: Beweis: Konto-Methode (oder Versicherung) Sanders: Algorithmen I runter: rauf: 97 s s ) ' 1 } − i s ( i in Zustand in Zustand Op Z )& Z n A s popBack ∈ ∈ n , n ≤ X i X ∑ Op ≤ −→ 1 ( amortisierte Gesamtkosten 3 pushBack { + Op −→··· c 2 s ≤ von Operation von Operation 2 Op −→ 1 ) ' s 1 1 − i

April 17, 2009 s Op −→ ( i c 0 s Op )& : T der Datenstruktur n ≤ i amortisierte Kosten tatsächliche Kosten ∑ ≤ : : ( 1 ) ) s s ( ( Zustand X : Menge von Operationen, z. B. X : tatsächliche Gesamtkosten T Berechnung A Z s ! ! ! ! ! für eine Konstante 3.3 Amortisierte Analyse – allgemeiner Die angenommenen amortisierten Kosten sind korrekt, wenn Sanders: Algorithmen I 98 . tatächliche tut das keine Abbruch.

April 17, 2009 oft möglich, aber kompliziert und teuer Echtzeitsysteme Parallelverarbeitung Laufzeiten sind leichter zu garantieren als Gesamtlaufzeit Wie geht das mit unbeschränkten Feldern? Anwendung: Anwendung: – – – Deamortisierung Amortisierte Der ! ! ! Amortisierte Analyse – Diskussion Sanders: Algorithmen I 99 pushBack popBack ...... stack deque FIFO queue pushFront popFront

April 17, 2009 efﬁziente Implementierungen wenig fehleranfällig vielseitig einsetzbar austauschbare, einfache Schnittstellen ! ! ! ! 3.4 Stapel und Schlangen Sanders: Algorithmen I t 100 ) 1 + n 0 ( b n ) ] 1 h [ mod + b ) n 1 ( + h h ( mod return ) := 1 t h + = n h isEmpty; + ) ¬ h isEmpty; − ¬ t ) return ( 1 ; Element Element } assert + : 1 of , n x ) ( 0 ( assert { N Element return : : ; n of n N Element; April 17, 2009 mod ] < : : ) n 1 .. popFront pushBack 0 size x + [ isEmpty ﬁrst size t ( := N ] N t := [ assert b t 0: Array 0: BoundedFIFO( : = = Procedure Procedure Function Function Function b h t Class Sanders: Algorithmen I 101

April 17, 2009 ,. . . splice Feldern Listen , -effizientes scanning Verschnitt Cache einfach kein Overhead für Zeiger beliebiger Zugriff kein remove flexibel ! ! ! ! ! ! ! Vorteile von Vorteile von 3.5 Vergleich: Listen – Felder Sanders: Algorithmen I 102 ’ ∗ explanation ‘ amortized amortized amortized cache-efficient not with inter-list splice insertAfter only removeAfter only amortized ∗ ∗ ∗ ∗ ∗ n 1 1 1 1 ∗ ∗ ∗ 11 nn nn n n nn nn 11 1 ∗ ∗ ∗ n 1

April 17, 2009 ∗ nn 11 11 11 n n n 11 11 111 11 1 11 1 1 1 1 1 1 1 List SList UArray CArray | ] · · splice ﬁndNext,. . . last insert | [ Operation popBack popFront concat pushBack pushFront remove ﬁrst

Sanders: Algorithmen I 22 2 103 20 2 Feld (Java) 18 Liste (Java) geordnet Liste (Java) 2 Liste (Java) randomized Liste (Java) n 16 2 14 2 Feld (C++)

April 17, 2009 12 2 Liste (C++) geordnet Liste (C++) Liste (C++) randomisiert Liste (C++) 10 2 0.1

0.01 time/n [sec] time/n 0.001 Iterieren Sanders: Algorithmen I Sanders: Algorithmen I April 17, 2009 104 Einfügen an zufälliger Position

Liste (C++) Liste (Java) Feld (C++) Feld (Java) 100

time/n [sec] 1

0.1

28 210 212 214 216 218 n 105 Kapitel 6 Kapitel 4 Kapitel 7

April 17, 2009 sortierte Folgen – einfügen, löschen, suchen, schnelles Einfügen, Minimum Entfernen schnelles Einfügen, Löschen und Suchen Bereichsanfragen,. . . Ausblick: Weitere Repräsentationen von Folgen Sanders: Algorithmen I Prioritätslisten: Suchbäume,. . . : Hashtabellen: 106 bringen”.

April 17, 2009 das, Dinge wiederzuﬁnden durcheinander hilft “völlig ≈ ” hash “to 4 Hashing (Streuspeicherung) Paradoxerweise Sanders: Algorithmen I 107 . ) 1 ( falls nichts gefunden O ⊥ ; k k = = } e e e , { } e ∪ { with . \ M M M M := ∈ ∈ Element. -Operationen in Zeit := e e M

April 17, 2009 : ⊆ M ) : M ) return : Key ) : Element Wörterbuch : k Key ( e : ( ist eindeutig für k ) ( e ( ﬁnd insert remove . . . key speichere Menge Hashtabellen unterstütze Sanders: Algorithmen I M M M 108 ich. . . ) $ ) e e ( ( key = Elemente Mengen Schlüssel key ). < / > / ) e ( haben repräsentieren e

April 17, 2009 gdw. key $ e elemente collection classes = Datenstrukturen < / > / e Viele (engl. auch Exkurs: Konventionen für Die Mengen Elementvergleich hier gleichbedeutend mit Schlüsselvergle Sanders: Algorithmen I 109 ? von Knoten, bereits durchsucht Join Teilmengen bei Script-Sprachen wie perl oder awk Duplikate

April 17, 2009 bei Compilern Stellungen wurden (wenn eine Tabelle in den Speicher passt) welche z. B. Suchraum ... Unsere Routenplaner: Assoziative Felder Datenbank-Gleichheits- Symboltabelle Schach (oder andere kombinatorische Suchprogramme): Auslieferungsregale der UB Karlsruhe Entfernen exakter ! ! ! ! ! ! ! ! Hashing: Anwendungen Sanders: Algorithmen I 110

April 17, 2009 Hashing mit Arrays Hashing mit verketteten Listen Analyse Grundidee ! ! ! ! 4.1 Überblick Sanders: Algorithmen I 111 t h M h ab, d. h., injektiv ]

April 17, 2009 1 M − m e .. Hash-Funktion 0 [ t ))] = e ( key Tabelle ( h [ bildet Elemente von auf eindeutige Einträge der Eine perfekte Ein (über)optimistischer Ansatz t Sanders: Algorithmen I 112 t h M

April 17, 2009 Beispiel: Geburtstagsparadox Perfekte Hash-Funktionen sind schwer zu ﬁnden Kollisionen Sanders: Algorithmen I 113 t[h(k)] < > <> <> <> <> <> <> <> <> < > < > < > von Elementen t h Folgen "

April 17, 2009 M k geschlossenes Hashing Tabelleneinträge: Elemente Beispiel Kollisionsauﬂösung Sanders: Algorithmen I 114 t[h(k)] < > <> <> <> <> <> <> <> <> < > < > < > t h M k ein. )] e ( h [ t . gefunden? gefunden? )] . k k k ( )] h k [ ( t )= )=

April 17, 2009 h e e [ ( ( t h h am Anfang von e mit mit zurückgeben. e e Durchlaufe ⊥ : Füge ) Durchlaufe : zurückliefern. löschen und zurückliefern. k ) : ( einfach verkettete Listen e ) ( " Sonst: " Element Element k ( Implementiere die Folgen beim geschlossenen Hashing durch 4.2 Hashing mit verketteten Listen Sanders: Algorithmen I ﬁnd remove insert 115 t "clip" remove t insert "slash"

April 17, 2009 t 00000000001111111111222222 01234567890123456789012345 abcdefghijklmnopqrstuvwxyz Beispiel Sanders: Algorithmen I 116 t[h(k)] < > <> <> <> <> <> <> <> <> < > < > < > t h M k ) ) | ) M |

April 17, 2009 ( O Listenlänge ( Listenlänge O ( : konstante Zeit ) O : k ) : ( e ) ( k ( Besser wenn wir genug Chaos anrichten? Analyse Aber wie lang werden die Listen? Schlechtester Fall: Sanders: Algorithmen I ﬁnd insert remove 117 . | } | 1 m (*) ) Key } Key 2 | } 0 ( m M −| 1 ]= | h m − 42 )= E e = m ]= [ )= ( 4 .. h h X P ] ( [ 0 p Hash-Beispiel : h { Y E [ : M E Ω ∈ ]+ ∈ e { X } h [ | 1 { E , = 0 = { X ]= 42 Y E → ) Hash-Funktionen y + Ω ( : X X [ y I Ω E p 1 R ∈ Ω x ∈ Ω y → | ∑ Ω von 1 Ω | : = 0 April 17, 2009 ] Ω = 0 X x X [ p x E : p E ∈ x : Teilmengen von ∑ = Wahrscheinlichkeit ] = E [ x p Erwartungswert Linearität des Erwartungswerts: Zufallsvariable (ZV) 0-1-Zufallsvariable (Indikator-ZV) Gleichverteilung P Ereignisse Elementarereignisse für den Hausgebrauch Etwas Wahrscheinlichkeitstheorie Sanders: Algorithmen I 118 t . ij I 1 1 + 52 i 365 . · = j n ] ) 26 ∑ ij 1 I 1 ≈ [ − 2 = . E n i . ) n 1 } j ( ∑ 730 n + ( n i n .. h ∑ 1 + = = j { = 2 } 1 X 1 6 2 n )= = 1 ∑ i i ( 7 364 = h .. + ]= 0 ij I ij { 1 2 I 5 gdw 1 − P = 1 + 1 i n ∑ = Ω + = = i j n n ∑ = ∈ 1 ij j n I = h ∑ 1 April 17, 2009 i ⇔ [ n = ∑ i 1 E ! = = = ] X [ E . n .. 1 Anzahl Paare mit gleichem Geburtstag: Deﬁniere Indikator-ZV Gäste Wieviele Gäste muss eine Geburtstagsparty “immindestens Mittel” haben, zwei Gäste dami den gleichen Geburtstag haben? Beispiel: Variante des Geburtstagsparadoxon Elementarereignisse: Sanders: Algorithmen I 119 : m . ) 2 n ( 23 Ω ≥ ist nur dann mit = n 1 m − m .. wenn 0 Hashtabelle der Größe → = n m .. , dass es zwei Gäste mit gleichem perfekt :1 h wetten

April 17, 2009 Verallgemeinerung: Jahreslänge Riesige Platzverschwendung. Standardfomulierung: Ab wann lohnt es sich zu Mehr zum Geburtstagsparadoxon Geburtstag gibt? Etwas komplizierter. Antwort: vernünftiger Wahrscheinlichkeit eine zufällige Hashfunktion Sanders: Algorithmen I 120 t[h(k)] 0 sonst. = < > <> <> <> <> <> <> <> <> < > < > < > e | t X m M | h und ]= 1 M M = ∈ e e X , [ ) k P ( . h M | ∈ ∑ } e ) . k )= ( e M ]= h ( e h X deﬁniere Listenlänge [ )= E k e ( M 1 für h ∈ ∑ . e : = ) e m M Listenlänge ( X ]= e ∈ O

April 17, 2009 X e von der Eingabe = { M ) | | ∈ ∑ 1 e ( [ M = 0-1 ZV | E O | )] = k ]= ( Für festen Schlüssel falls Die erwartete h X unabhängig ) [ [ t 1 | E ( = O : Das gilt X ist Satz 1. Betrachte die Analyse für zufällige Hash-Funktionen Beweis. Sanders: Algorithmen I 121 . Tabelleneintrag pro Schlüssel

April 17, 2009 unrealistisch meist unsinnig meist zu teuer Zufällige Schlüssel? " Weniger naive Lösungen: kompliziert, immer noch viel" Platz. " Naive Implementierung: ein Zufällige Hash-Funktionen? Sanders: Algorithmen I 122 . 1 m , ]= H 1 ∈ = e X [ P . 1 m universell Ω ist )] = y ( y und zufälligem h H Key h } 8= 1 )= − x ( m “einfache” Hash-Funktionen h mit x [ .. 0 haben wir immer noch P {

April 17, 2009 Key ⊆ H = H Ω Für Theorem 1 gilt auch für universelle Familien von falls für alle x, y in Deﬁnition 1. Der Rest geht wie vorher. Idee: nutze nur bestimmte 4.3 Universelles Hashing Beweis. Hash-Funktionen. Satz 2. Sanders: Algorithmen I 123 a . = h (x) 9 k deﬁniere } k 1 } 1 − − m k .. } m mod m 0 1 { − ∈ ,..., m * 3 3 a 0 a x : { a ∈ + ,..., h ) 0 8 k { a = 2 2 * ⊆ a x · H ,...,

April 17, 2009 1 + a m, ( 1 1 = zahl, Key * a x a x mod Prim · a Für )= x ist eine universelle Familie von Hash-Funktionen sei eine ( · a h Satz 3. m Eine einfache universelle Familie H Sanders: Algorithmen I 124 : j ) y y ) ( a 8= m h j x )= mod x mit ( )( ) a i k h x ) y . ). m − j 1 m i mit y j 8= ,..., ( = i 1 i a mod a y 1 k k − ) )( k ≤ i i m =( x m m ≤ 1 y ∑ , − j , i ) 8= y k i )] = ( mod genau ein x 1 i y ( a ( − ∃ i ) k a y , j . i j h ≤ ) i y ,..., a y 1 k ≤ 8= ( x − 1 s, d. h., ∑ ≤ , auszuwählen (mit a i )= i j j a i h ∑ x x ≤ 8= ( a s, =( i 1 ( i a

April 17, 2009 a x h ≡ ≡ ≡ )= [ i j x ) P j x ( a i a y a h k ⇔ − ≤ j i x ∑ ≤ ( Betrachte 1 j -s mit a a Möglichkeiten 1 ⇔ ist die Gesamtzahl − k k Für jede Wahl von m m zähle Beweis. Sanders: Algorithmen I 125 9 9 k } × 1 0 w − x } w 1 .. k , 0 { 1 0 a x } { 1 2 ∈ x aw − M m ] : i x .. x 0 [ M i { t h 1 ∈ 8 = b i i t = : : ) ⊕ b , d. h., xor, and) t ⊕ H 0 ,..., x [] 1 t ⊕ ( mod 2 h 8 )) = b x = k [] } ⊕ 1 ,..., , H 1 0 April 17, 2009 (Arithmetik x { , x 0 = x M (( ) b t )= , Key x w ,..., ( [] 2 1 t M ⊕ ( h h = m Bit-Matrix Multiplikation: Sei Bit-basierte Universelle Familien wobei wobei Tabellenzugriff: Sanders: Algorithmen I 126 t h M (Linear Probing)

April 17, 2009 : Suche nächsten freien Platz. Cache-effizient einfach platz-effizient ! ! ! linear probing Kollisionen werden durch Finden anderer Stellen aufgelöst. Offenes Hashing: zurück zur Ursprungsidee. Elemente werden direkt in der Tabelle gespeichert. 4.4 Hashing mit Linearer Suche Am Ende fange von vorn an. Sanders: Algorithmen I t m m’ 127 h ⊥ ) 1 8= ] − i [ M t m : .. 0 } 1 → − Element ; i .. of Key ]) ] do do : i [ 1 t h ⊥ ⊥ ( ; ] − i h $ [ 8= 8= N { t ] ] m : i i [ [ ∈ $ ) t t + j m , m .. 1 m Element ( 0 [ − while while $ ): Element ⊥ ⇒ ∀ ∞ ∞ : m then return e 8= Key + ( to to ] k : i April 17, 2009 Array ) ) [ m k t e e : ( ( ( : ]= < ] h h i i insert ⊥ [ i ∀ t e ⊥ find := := if i i := ] i ,..., [ for return for assert t ⊥ BoundedLinearProbing =[ Function invariant Procedure t Class Der einfache Teil Sanders: Algorithmen I 128 k search // ⊥ nothing to do 8= ] i // [ erase freed entry t : move planned hole // } 1 // − i .. ) do x ]) Overwrite removed element i ( . do [ ] ⊥ ] t j // i ( [ [ 8= t h t ] { j 8= [ ∈ t k , remove . j ] i ) ,... z while Key while , then ] : y j ⊥ ⇒ ∀ ∞ i , hole at

April 17, 2009 ∞ k [ ) then return t z ( x 8= ( to ≤ to h j ] ⊥ := i 1 ) ]) [ ] j t k i := [ + [ ( : ..., ]= t i i t h i i remove ( [ ∀ h t ⊥ Establish invariant for =[ := := t j if // if i := ] we plan for a i [ // for for t Procedure invariant Beispiel: Remove Sanders: Algorithmen I 129 12 hack hack hack hack hack hack hack slash v j kx l m 8 lop hu hash hashhash slash hash lop slash hash lop slash hash lop hash clip 6 remove er fs axe axe axe axe axe axe axe axe axe axe axe axe axe axe

April 17, 2009 clip lop slash lop lop slash : axe, chop, clip, cube, dice, fell, hack, hash, lop, slash hash, lop, fell, hack, cube, dice, chop, clip, : axe, p q t w y z 234 c d g i chop cube dice fell chop cube dice fell chop clipchop cube dicechop cube dice cube dice fell fell fell chop clip cube dice fell chop clipchop clipchop clipchop cube clip dice cube dice cube dice cube dice fell fell fell chop chop clip chop clip cube insert n 0 1 5 7 9 10 11 a bo tt

Sanders: Algorithmen I 130 , Füllgrad , n doall Hashing hat nur amortisiert konst. Lineare Suche speichert Zeiger oder item), Nur bei Verketten ! ↔

April 17, 2009 t Kompliziert! Abhängig von offenes Universelles Hashing funktioniert so nur mit , Implementierungsdeteils bei Verketten Verketten weniger empﬁndlich. Lineare Suche besser. Vor allem für Unbeschränktes (shared dummy!, Elementgröße Einfügezeit Speicherverwaltung bei Verketten, beschränkt oder nicht,. . . Verketten 4.5 Verketten Sanders: Algorithmen I Leistungsgarantien: Referentielle Integrität: Platz/Zeit Abwägung: Cache: Volllaufen: 131

April 17, 2009 hier nicht 4.6 Perfektes Hashing Sanders: Algorithmen I 132 schlechtesten Fall

April 17, 2009 ﬁnd / perfektes Hashing ) höhere Anforderungen and die Hash-Funktionen 1 ( (peer to peer Netze,. . . ) " Platten hinzufügen / ersetzen O Verschiedene Plattengrößen und Geschwindigkeiten Hashing als Mittel zur Lastverteilung z. B., storage servers, Hohe Wahrscheinlichkeit und Garantien für den ! ! ! ! ! Mehr Hashing Sanders: Algorithmen I 133

April 17, 2009 5 Sortieren & Co Sanders: Algorithmen I 134 ’ ≤ ‘ 6 n e ,..., 1 e 5 mit lineare Ordnung s = 6 $ n s e

April 17, 2009 für eine ,..., $ n $ 1 e e 5 = $ s ≤···≤ ist Permutation von $ 1 $ e s ! ! Gegeben: Elementfolge Gesucht: Formaler Sanders: Algorithmen I 135 unsortierte Liste ↔

April 17, 2009 Telefonbuch Gruppieren (Alternative Hashing?) Allgemein: Vorverarbeitung Suche: ! ! ! Anwendungsbeispiele Sanders: Algorithmen I 136 dünner Join Transposition aufbauen, Konversion zwischen

April 17, 2009 invertierten Index Scheduling, die schwersten Probleme zuerst Sekundärspeicheralgorithmen, z. B. Datenbank- Verarbeitung von Intervallgraphen (z. B. Hotelbuchungen) Rucksackproblem Aufbau von Suchbäumen Kruskals MST-Algorithmus ! ! ! ! ! ! Viele verwandte Probleme. Zum Beispiel Matrizen, Beispiele aus Kurs/Buch Graphrepräsentationen. Sanders: Algorithmen I 137

April 17, 2009 untere Schranke – ein erster efﬁzienter Algorihtmen ganzzahlige Schlüssel – jenseits der unteren Schranke Quicksort das Auswahlproblem Mergesort Eine passende Einfache Algorithmen / kleine Datenmengen ! ! ! ! ! ! 5.1 Überblick Sanders: Algorithmen I 138 ) Element of ] n ] .. 1 1 [ − i [ a Array : a ( ≤···≤ ] 1 [ April 17, 2009 a do to the right place n ] i [ a to " " " insertionSort 56 6 6 6 , 1 1 1 := 2 6 5 , , invariant move i 7 , 1 1 , 6 5 , 4 7 , 7 , , 6 5 for 1 4 7 , , , , 6 1 1 4 4 5 5 5 Procedure Sortieren durch Einfügen (insertion sort) 5.2 Einfache Sortieralgorithmen Beispiel: 5 Sanders: Algorithmen I ] 1 − j 139 [ a := ] j [ a do as a sentinel e ] ) new minimum 1 ] > [ 1 ] a // 1 − j − [ use j Element a [ // a of := ] ] j n ] [ .. 1 a 1 [ while − i [ ∞ do a − 2 Array : a ( ≤··· ≤ ] downto downto to the right place 1 i i [ April 17, 2009 ] then e e a i do [ := := ] a 1 j j n := := [ ] ] ] j a 1 i to [ [ [ a a for for am Beispiel Sortieren durch Einfügen a < insertionSort move e := := 2 invariant else // e if i for Procedure Sentinels Sanders: Algorithmen I 140 . " 2 n ! Θ ) n = ( 1 O − z. B. (beinahe) sortiert ) )= . ) 1 ) 1 i 1 ( ( ( 2 + O i O O ( 2 i n = ∑ i = i 2

April 17, 2009 n = ∑ i -te Iteration braucht Zeit -te Iteration braucht Zeit i i Die Bester Fall Die Schlechtester Fall Analyse Sanders: Algorithmen I 141 base case // )) 6 , n ) e 6 @ Element 2 / n of ? ,..., 1 e + @ 2 / ,..., n ? 1 b e e 5 5 Sequence ( ( und ): 6 a n e 6 1 e 5 mergeSort mergeSort b ,..., 1 ( e 5 und ( April 17, 2009 a merge then return 1 mergeSort = n sortierte Folge if else return Gegeben: zwei Mischen (merge) Berechne: sortierte Folge der Elemente aus Function Idee: Teile und Herrsche 5.3 Sortieren durch Mischen Sanders: Algorithmen I 142 6 6 1 6 1 5 , 8 6 , 8 6 6 5 1 1 8 8 , 5 , 8 8 6 , 6 , 6 1 2 2 6 6 2 8 , , 5 , , 2 8 8 8 , , 1 8 6 , 5 5 , 8 2 8 2 5 5 7 5 , , 65 8 2 , 1 , 6 6 5 1 2 7 1 , , , , 7 6 1 1 6 7 , 6 7 , 5 5 1 2 7 5 1 , 5 , 5 7 2 , , 6 2 1 5 2 5 5

April 17, 2009 split split split merge merge merge Beispiel Sanders: Algorithmen I 143 ) n ( O a b a b a b move move move move move concat operation 6 8 , 6 6 8 7 , , 6 2 , 6 7 2 2 , , , 6 2 1 , , c 2 2 1 1 56 , , , 5 1 1 , 5 2 1 1 , , 5 1 5 1 1 , 5 1 5 6 6

April 17, 2009 6 6 8 8 , , 6 6 8 8 in die Ausgabe schieben. Zeit , , 8 8 8 8 , , , , 8 8 ) , , 2 2 8 8 b , , 2 2 , 1 1 a ( 65 min 65 65 7 , 65 65 7 7 , , 2 7 7 ab 56 5 56 56 , 5 5 2 2 5 5 1 5 Jeweils Mischen Sanders: Algorithmen I 144 . ) n log 6 n 6 ( 1 6 1 5 , O 8 6 , 8 6 6 5 1 1 8 8 , 5 , )= 8 8 @ 6 , 6 , 6 2 1 2 2 6 6 2 8 , , / 5 , , 2 8 8 8 n , , 1 8 6 , 5 ? 5 , 8 2 8 ( 2 5 5 7 5 , , T 65 8 2 , 1 , 6 6 5 1 2 7 1 )+ , , , , * 7 6 1 1 6 7 , 2 6 7 , 5 5 1 2 / 7 5 1 , 5 , n 5 7 2 ) , , ( 6 2 1 T 5 2 5 5 )+

April 17, 2009 n ( O split split split merge merge merge )= n ( T Analyse: Analyse Sanders: Algorithmen I 145 ) @ 2 / n ? ( T )+ * 2 / n ) ( T )+ aufblasen n ( anhängen) O ∞

April 17, 2009 × )= ) n n ( T ) − n * Zweierpotenz n Runderei log log ) n 2 ( ( O Problem: Zeit " normales Master-Theorem anwendbar Eingabe auf Ausweg: genauer rechnen (siehe Buch) Dirty trick: Analyse (z. B. Sanders: Algorithmen I 146 – Algorithmen. schwer zu beweisen denkbaren ? ) n log n ( Θ April 17, 2009 einer Verbesserung i.allg. Unmöglichkeit sie erfordert eine Aussage über alle Geht es schneller als 5.4 Untere Schranken einschränkende Annahmen " Sanders: Algorithmen I 147 r durch sind. n .. 1 ) n ( O − n ?. log j n e ≤ i e

April 17, 2009 solche Permutationen. ! n Deterministische vergleichsbasierte Sortieralgorithmen Betrachte Eingaben, die Permutationen von Beweis: Vergleiche im schlechtesten Fall. Vergleichsbasiertes Sortieren: Informationen über Elemente nu Zwei-Wege-Vergleich Eine vergleichsbasierte untere Schranke Satz: brauchen Es gibt genau Sanders: Algorithmen I 3 e 1 > e 2 148 e < > 3 > e 1 e ≤ > 2 e 3 e ? 2 e 3 e 3 ? e 1 > e n ≤ e 1 ≤ e < ,..., 1 2 ≤ e e 2 e ? 1 e 2 e T ≤ 1 e > Tiefe 3 < ≤ e 3 ? e 1 e April 17, 2009 3 e ? 2 e 2 e ≤ 3 < e 3 e ≤ ≤ 2 ≤ e 1 e ≤ 1 e Baumbasierte Sortierer-Darstellung Mindestens ein Blatt pro Permutation von Ausführungszeit entspricht Sanders: Algorithmen I 149 . ) n ) ( 1 O − − n n ln ( log n n n ≥ n = n 1 = = e ≤ x x = ! ) n log 1 n ≤ − n − n x . . n ln e n e n ( - - x log Blätter. < n = T 2 = n n = e n n . = xdx e n n ln - n ln n e 1 n e ; log April 17, 2009 : ≥ ≥ = hat höchstens i n ) ) 1 T ! e n ln − n ( n n ()&' ≥ ≤ ln i ( linken Teil ! ∑ Tiefe ≤ n n 2 e log ≥ ≥ = ≥ ! ! T n n 2 T ln ⇒ Einfache Approximation der Fakultät: ⇔ Baum der Beweis ⇒ Beweis für Sanders: Algorithmen I 150 Vergleiche. ) n ( O − n

April 17, 2009 log n Beweis: nicht hier. Satz: immer noch Randomisierung, Mittlere Ausführungszeit Sanders: Algorithmen I 151 Element ) c of ( dersrum“. Sequence ): , and quickSort b , ) a ( Element of s Sequence 6 6 6 s : p p p

April 17, 2009 s ∈ ( = < > p e e e rekursivem Aufruf : : : then return s s s vor 1 concatenation of quickSort ∈ ∈ ∈ quickSort e e e ≤ “some” 5 5 5 | s | := := := c b a return pick if Function Idee: Teile-und-Herrsche aber verglichen mit mergesort „an Leiste Arbeit 5.5 Quicksort – erster Versuch Sanders: Algorithmen I 152 , . Fall 1 2 = ≥ n n if if " ) 2 1 n ! − Θ n ( (oder Max.) der Eingabe T )= schlechtesten 1 )+ ) + n 1 ( ( ··· Θ Θ Minimum    )+

April 17, 2009 1 )= − n n ( T +( n ( Θ )= n ( ⇒ T Quicksort – Analyse im Annahme: Pivot ist immer Sanders: Algorithmen I 6 9 6 9 65 , 8 8 153 6 56 5 9 , 7 , 65 8 7 6 9 , 56 5 7 , 8 , 6 65 6 6 9 , 5 , 56 5 7 , 8 , 6 65 5 6 9 , 5 , 4 , 56 5 7 , Schlechtester Fall: Beispiel 8 , 65 6 6 4 9 , 5 , 4 , 7 56 5 , 8 , 6 6 65 , 9 , 3 3 5 , 4 , 2 , 56 5 April 17, 2009 7 , 6 8 , 9 65 , 6 , 2 5 , 3 4 , 2 , 7 56 5 , 6 1 , 9 , 8 , 65 5 , 6 1 , 4 , 3 2 , 7 , 56 5 0 , 1

Sanders: Algorithmen I , 65 8 , 0

6 ,

5 56 5 154 , . 1 2 ≥ = n n if if ) Fall @ 2 / 6 n 6 ? ( 6 T 5 der Eingabe besten , 65 2 4 5 , 6 )+ ) 6 n 1 65 ( ( 5 Median , 4 O O 5 4 ,    2

April 17, 2009 , 65 ≤ 0 3 , 5 ) ) 1 n n , ( 6 6 T , 2 log 3 n 5 6 ( 2 O 65 , 1 0 , 1 )= 5 (Master-Theorem) n 65 ( 0 ⇒ T 5 Quicksort – Analyse im Problem: Median bestimmen ist nicht so einfach Annahme: Pivot ist immer Sanders: Algorithmen I 155 6 9 Element ) c 6 of ( 9 65 , 8 7 , 8 65 6 7 9 5 , Sequence 5 , ): 65 4 , and quickSort , 6 b 5 7 , , ) 8 a , 6 ( 6 Element 5 6 9 , of 6 5 65 , 5 , 4 4 , 4 5 2 s , 7 , 56 5 0 Sequence , 6 6 6 : 1 p p p

April 17, 2009 s , 65 ( 8 3 = < > , 5 e e 6 e , uniformly at random : : : 3 6 then return s s s s 5 2 1 concatenation of quickSort ∈ ∈ ∈ ∈ quickSort 6 e e p e ≤ 2 5 5 5 | 65 , s 1 0 | , := := := 1 c b return pick a if 5 65 0 5 Function Quicksort – zufälliger Pivot Sanders: Algorithmen I 156 | s | // ) Element ) n 3-Wege c of ( // log Vergleiche n // ( Warum ‘OBdA’? O zu zählen. Sequence ) n ( ): , and quickSort C b ) , ) ,> )] a ( n Element = ( C of [ <, E )= s n ( ¯ verschieden C Sequence 6 6 6 Vergleiche ( : p p p

April 17, 2009 s ( < = > e e e uniformly at random : : : 3-Wege then return s s s s 1 concatenation of quickSort ∈ ∈ ∈ ∈ quickSort e e p e ≤ 5 5 5 | s | := := := b c return pick a if Genauer: wir bestimmen Function Annahme: alle Elemente Es genügt, die 5.5.1 Satz: Quicksort hat erwartete Laufzeit Sanders: Algorithmen I 157 das 2 / 1 ist. 3 4 : 4 1 zu zeigen. n ) n log n log n 45 . ( 1 O ≤

April 17, 2009 n )= n ln ( ¯ n C 2 ≤ ) n ( ¯ C Satz: Beweisansatz 2: Genauere, elegantere Analyse Das genügt um Im Buch wird bewiesen, dass mit Wahrscheinlichkeit Beweis: Beweisansatz 1: Rekurrenzen Aufspaltverhältnis nicht schlechter als Sanders: Algorithmen I 158 . 6 1 = ij . X 5 P 1 + i n ∑ = j verglichen 1 j $ n = ∑ e i ]= n ij X [ wird mit E $ i log 1 e n + i n ∑ = j 45 gdw. . 1 1 n = ∑ i ≤ := 1 = ij n ? X ij ln sortierte Eingabefolge.

April 17, 2009 X 1 6 n $ n + 2 i n e ∑ = j ≤ 1 ) n = ,..., ∑ i n $ 1 > ( e 5 ¯ E C = = $ ) s n ( ¯ Sei Satz: Indikatorzufallsvariable: C Sanders: Algorithmen I 159 gewählt wird. 6 1 6 − $ n j $ e e ,..., ,..., 1 1 + j + $ $ i e e , 5 j $ ' e 1 , 1 + i 2 − j $ − e j Elemente )& = 1 ,..., + 6 i 1 1 − + $ i j e

April 17, 2009 , = $ i 1 e ( + ij , i 2 1 − X j − 5 $ i e verglichen = P j $ 6 e wird Pivot bevor ein Pivot aus 1 j $ ,..., e $ 1 = e 5 ij := 1 X wird mit oder = 5 ij $ i $ i $ e e ⇒ P Lemma: ⇔ Sortierte Eingabefolge: s ⇔ X Sanders: Algorithmen I 160 ) . n ln n 2 )= 1 − n n harmonische Summe ( ln log + n 1 ( 1 45 n . 2 + 1 i 2 ≤ − ≤ ) j k 2 1 n 1 1 k 2 2 − + k + 1 i 2 i ln n

April 17, 2009 = n ∑ 2 ∑ n k − = = n ∑ j n n k H = ∑ k ( 2 1 1 1 n n n n n = = = ∑ ∑ ∑ i i i 2 2 ≤ = = = ≤ ) )= n n ( ( ¯ ¯ C C Satz: Sanders: Algorithmen I 161 n ln + 1 = dx x 1 n 1 ; + 1 ≤ i 1 n ≤ i ∑ ≤ 1 ≤

April 17, 2009 1 2 3 4 5 6 7 8 dx x 1 n 1 1 ; = n ln Exkurs: Harmonische Summe Sanders: Algorithmen I 162

April 17, 2009 2-Wegevergleiche Array-Implementierung „inplace“ ! ! ! 5.5.2 Quicksort: Efﬁziente Implementierung Sanders: Algorithmen I 163 r j ← → i −− j ) N ; : r ! !, ++ i ; : a ; −− // ++ j ]) i j [ r a do Element do , ] j j i [ )] r a ≤ ≤ ↔ ( i i ,!, ∧ ∧ a i ( p p swap Array of

April 17, 2009 j : > < ] a ] j ( i then [ [ ) ) j a a j r r j ↔ , i then return qSort ≤ ,!, , := > j i r pickPivotPos a a i [ ! ( ( ; a while while if ≥ ! : ! a := := p qSort until // repeat if qSort i Procedure Sanders: Algorithmen I 164 j r r 459 459 3 2 3 ↔ = p 7 73459 stop 0 6 6 7 3 4 5 9 just swapped scanned over ji 81 81 18

April 17, 2009 6 86 1 00 7 →← ↔ i ! ! 3 2 2 20 Beispiel: Partitionierung, Sanders: Algorithmen I 165 | | || || |3| 4|5 || | 6|7| | | | |5 6| | | | |

April 17, 2009 2 0 1|81 6 0|2|5 7 60 3 7 1| 4 3 |4 5 4|8 3|7 9 9 6 5|8 9 3681072459 Beispiel: Rekursion Sanders: Algorithmen I 166 r j ← → i −− j ) N ]) ; : r r !.. ! [ !, ++ a i ; : ( a ; −− // ++ j ]) i j [ r a do Element do , ] j j i [ )] r a ≤ ≤ insertionSort ↔ ( i i ,!, ∧ ∧ a i ( p p swap then Array of

April 17, 2009 j : 0 > < n ] a ] j ( i then [ [ ) ≤ ) j a a j r r j 1 ↔ , i qSort ≤ + ,!, , := > j i pickPivotPos a a ! i [ ! ( ( ; a if while while − ! : r a := := p until // qSort repeat if qSort i Procedure Größerer Basisfall Sanders: Algorithmen I 6 9 6 9 65 , 8 8 167 6 56 5 : 9 , 7 , 65 8 7 6 9 , 56 5 7 , 8 , 6 65 6 6 9 , 5 schlechtesten Fall , 56 5 7 , für Rekursionsstapel. Im 8 , Inplace? Wirklich? ) 6 65 n 5 6 ( 9 , 5 O , 4 , 56 5 7 , 8 , 65 6 6 4 9 , 5 , 4 , 7 56 5 , 8 , 6 6 65 , 9 , 3 3 5 , 4 , 2 , 56 5 April 17, 2009 7 , 6 8 , 9 65 , 6 , 2 5 , 3 4 , 2 , 7 56 5 , 6 1 , zusätzlicher Platz – kein Problem. 9 , 8 : , 65 rekursive Implementierung ) 5 , 6 1 n , 4 , 3 2 , Rekursion auf kleinere Hälfte halb 7 log , 56 5 ( 0 , ! ! 1 Im Mittel O Als Garantie für schlechtesten Fall:

Sanders: Algorithmen I , 65 8 , 0

6 ,

5 56 5 168 )] r j i ,!, := a := ! ( r ) ; ; N ) ) j : r , r i ,!, , !, a a ; ( ( r pickPivotPos [ a qSort qSort Element ↔ i do then j 0 using pivot ]) n 2 ] r / Array of r )

April 17, 2009 > : r !.. !.. [ 1 a ↔ [ a ( + a ( + ! ( ! ! − qSort < : r i a // if else partition while insertionSort Procedure Halbrekursive Implementierung Sanders: Algorithmen I 169 )] r j i ,!, := a := ! ( r ) ; ; N ) ) j : r , r i ,!, , !, a a ; ( ( r pickPivotPos [ a qSort qSort A Element ↔ 0 n n i do log then j 0 @ using pivot ]) n 2 ] r / Array of ≤ r )

April 17, 2009 > : r !.. !.. [ 1 a ↔ [ a ( + a ( + ! ( ! ! Induktion. Teilproblemgröße halbiert sich (mindestens) − qSort < : r i a // if else partition Rekursionstiefe while insertionSort Satz: Procedure Halbrekursive Implementierung mit jedem rekursiven Aufruf Beweisidee: Sanders: Algorithmen I 170 untere Schranke) ≈ ) Mergesort qsort: möglich bei sorgfältiger Pivotwahl ↔ qsort: leicht bei Aufgabe der inplace-Eigenschaft

April 17, 2009 deterministisch Elementvergleiche ( det. Varianten (proportion extend sort [Chen 2001]) ) ∃ n ( Zeit ( ) O n + qsort: (gleiche Elemente behalten Reihenfolge bei) n log n ( log Etwas schneller? inplace Stabil n O ! ! ! ! ! Pro Quicksort Vergleich Quicksort Pro Mergesort Sanders: Algorithmen I 171 : n = Element | s | ): N mit : s . a k Element; k . ) of y ( r mit with rank -te Element von < ) n s ) i ( .. x r ( 1

April 17, 2009 Sequence r : der Elemente einer Folge nicht notwendig eindeutig? → s k ⇒ r ( n ] j ≥ ist das .. [ | ] s Rang i s :1 [ | select a r < ] i [ s : assert j , return an element of i Function Abbildung ∀ // Frage: warum ist Deﬁnition: 5.6 Auswahl (Selection) Grob: Das Sanders: Algorithmen I 172 * 2 / | s | ) = k (10 % ,. . . ) auf vielversprechendste Elemente auswahl:

April 17, 2009 Quantile Median eingrenzen Spezialfall allgemeinere ! ! Statistik Auswahl – Anwendungen z. B. Eingabe 5.6.1 Unterprogramm Sanders: Algorithmen I 173 6 p k c k k ,..., pivot key p b 5 // a = b Element ): a N a : // // // ) k , a p ( Element; k ) | b of | − select | a | 6 6 6 − p p p k

April 17, 2009 Sequence , then return : c < = > k ( s k e e e ( : : uniformly at random : ≥ ≥ then return | s s s s | b k s select | ∈ ∈ ∈ ∈ | select e e ≥ e + p 5 5 5 | | a a | | := := := a pick c return b if if assert quicksort mit einseitiger Rekursion Function ≈ Quickselect Sanders: Algorithmen I 6 8 , 5 , 3 174 , 6 5 , 8 , 6 , 9 9 , 5 , 4 , 3 6 56 5 65 65 , 6 2 5 , 5 65 5 , 65 3 , 3 65 , 5 , 1 4 5 , 5 , 3 5 4 , 3 5 p a b c 2 6 5 4 4 6

April 17, 2009 6 8 6 , 8 5 , , 6 5 3 , , 5 , 3 5 , , 3 , 5 6 , , 5 , sk 6 2 , , 5 , 9 9 , , 4

, 5 5 , , 3

Beispiel 5 4 Sanders: Algorithmen I 4

, ,

3 1

5 ,

April 17, 2009 Sequence , then return : c < = > k ( s k e e e ( : : uniformly at random : ≥ ≥ then return | s s s s | b k s select | ∈ ∈ ∈ ∈ | select e e ≥ e + p hier nicht 5 5 5 | | a a | | quickselect hat erwartete Ausführungszeit := := := a pick return if c if b assert Beweis: Satz: Function Quickselect – Analyse Sanders: Algorithmen I 176 : (z. B. einfache Variante von quickselect) wer

April 17, 2009 Auswahl: quickselect mit spezieller det. Pivotwahl Verallgemeinerungen mehrere Ränge, teilweise sortierte Eingaben,. . . weiss wie es geht? analog quicksort Weitere partielles Sortieren Deterministische Tuning (array, inplace, 2-Wege-Vergleiche, iterativ) ! ! ! ! Mehr zum Auswahlproblem Sanders: Algorithmen I 177 .

April 17, 2009 schlechte Nachricht? = Hinweis, welche Annahmen man in Frage stellen muss Ganzzahliges Sortieren Nein: u.U. Untere Schranke 5.7 Durchbrechen der unteren Schranke – Beim Sortieren: Mehr mit den Schlüsseln machen als nur Vergleichen. Sanders: Algorithmen I 178 ] 4 [ b ] 3 [ b Element ] of 2 [ b e ] 1 [ b ) e ) Sequence ] ( 1 ] 0 of [ − ] b s 1 K [ Element − b pushBack K of . .. )] 0 ,..., [ e ] ( 0 [ b key [ b Sequence Array

April 17, 2009 : : do s ( s 566 ∈ ) Sort e K K ,..., + concatenation of n 556 ( := = O s foreach b Schlüssel – Eimer-Sortieren (bucket sort) Zeit: Procedure K Sanders: Algorithmen I 6 ) g 179 , 3 ( , . ) 6 6 ) ) d i g , , , 3 1 3 ( ( ( , , , ) ) ) a Element h , d , , 3 2 of ( 3 ( 5 ( , , ) ) 6 g a ) , , h 3 3 , ( ( , 2 ) , ) ( e ) ) Sequence ] , f ( h ) 1 , , c of 0 , 2 − ( ] ( 2 , , 1 ( ) K ) 5 [ e c Element − , b , 6 0 2 pushBack K ) ( of . i ( , .. , , ) )] 0 ) ,..., 1 [ e i d ] ( ( , , 0 , [ 1 3 ) ( ( b b key , , , [ ) ) 1 b b c Sequence ( Array , ,

April 17, 2009 5 : : 1 2 do s ( ( 3 6 " ( , , s ) ) ) f 566 f = b ∈ , , , Sort e 0 1 0 K K ( ( ( , , , ,..., ) ) ) e concatenation of a e " , , , 556 0 3 0 := ( = ( ( 5 s foreach b 5 5 = = = b verteilen s s aneinanderhängen Procedure Beispiel: Sanders: Algorithmen I 180 move i ) refer Element of ] refer N n refer .. of 1 ] [ b a c 1 − ) ])]++ i K C [ , a .. ] Array ] ( 0 k i : [ [ [ c a b , key [ do a + c := ( 1 C

April 17, 2009 ( − Array ])]] do do i : [ := ])]++ K n n a i [ 6 ( ]) a 0 to to to k ( [ key c KSortArray [ , c key := 0 [ ,..., [ := 1 := 1 C b ( c 0 k i i 5 := 0 = for for for c C Procedure Array-Implementierung Sanders: Algorithmen I 181 0 1 ... ) x ( i digits key Reihenfolge. ... ) −1 d relative 0 x Element .. i // ihre of K mod ) behalten i K Sequence : , d. h., s igit Radix-Sortieren div ( x D ( stabil Schlüssel

April 17, 2009 do ) as x 1 ( )) − K key gleichem d LSDRadixSort + ) s is sorted with respect to digits n igniﬁcant- to ( mit ( s S d ( := 0 O Schlüssel – invariant redeﬁne KSort i d east- Zeit: Procedure for Elemente L K Beobachtung: KSort ist Sanders: Algorithmen I 182 [Han Thorup 2002] (erwartet) für ganzzahlige Schlüssel, die in ein

April 17, 2009 " n kann besser sein. (Cache-Misses, TLB-Misses) K loglog √ n ! O im Mittel Cache-efﬁzienter aber Probleme mit schlechtestem Fall Kleineres Nicht (ohne weiteres) inplace MSD-Radix-Sort: Wichtigste Ziffer zuerst. ! ! ! Zeit Mehr Theorie: Mehr zu ganzzahligem Sortieren Maschinenwort passen. Sanders: Algorithmen I 183 ) ganzzahlig ↔ Eingabeverteilungen

April 17, 2009 Algorithmenbibliotheken schneller -Efﬁzienz weniger schwierig (z. B. wichtig für Cache robust gegen beliebige weniger Annahmen asymptotisch ! ! ! ! Sortieren: vergleichsbasiert pro vergleichsbasiert pro ganzzahlig: Sanders: Algorithmen I ... 184 Mehrwegeverteilen Mehrwegemischen ...... (als übernächstes) "

April 17, 2009 Mehrwegeverteilen (kommen als nächstes) Algorithmenbibliotheken " : oft noch wichtiger als intern Extern Parallel Mehrwegemischen Sortieren durch Dynamische sortierte Listen Prioritätslisten quicksort Verfügbar in (binary) mergesort ! ! ! ! ! " " Verallgemeinerungen: Mehr zum Sortieren Sanders: Algorithmen I 185

April 17, 2009 6 Prioritätslisten Sanders: Algorithmen I 186 Schlüsseln mit M min Elementen

April 17, 2009 e von ∪ M M := return and remove M : : ) e ( Verwalte Menge Prioritätslisten (priority queues) Sanders: Algorithmen I Insert DeleteMin 187 (klein)

April 17, 2009 run formation für externes SortierenTime forward processing (groß) (riesig) Simulation diskreter EreignisseBranch-and-Bound Suche (mittel–groß) (groß) Mehrwegemischen Greedy Algorithmen (z. B., Scheduling) (klein–mittel) ! ! ! ! ! ! (ohne zusätzliche Operationen) Prioritätslisten – Anwendungen Sanders: Algorithmen I 188 4 8 2 v 9 6 ≤ ) 7 v ( parent : v ∀ Wurzel–Blatt , fehlende Blätter rechts unten. ) @ n n Pfades log log ( ? O Zeit Wurzel =

April 17, 2009 : Bäume (oder Wälder) mit Minimum Heap: Binärbaum, Höhe Beobachtung: Idee: Änderungen nur entlang eines Binärer Heap-Eigenschaft 6.1 Binäre Heaps " insert, deleteMin brauchen Sanders: Algorithmen I 189 q q z 10 11 12 13 js js w w h p p d d r rz cg a a c g h 123456789 : j h: 1 + j @

April 17, 2009 j 2 2 : / 2 ) j : j ) ? ( j ] n ( .. )= 1 j [ ( h linkes Kind rechtes Kind parent Array Schicht für Schicht ! ! ! ! ! z. B. Turnierbäume, statische Suchbäume Nicht nur nützlich für heaps: Implizite Baum-Repräsentation Sanders: Algorithmen I 190 q q z 10 11 12 13 js js w w h p p d d ] 1 rz r [ h ] j [ h cg ≤ a c g h a 123456789 ] return @ ; 2 : Element j 0 h: / j of > ? [ ) n h N : Element : n w .. of ( 2 April 17, 2009 ] assert w ∈ .. j 1 ∀ [ min N 0: Array BinaryHeapPQ : = invariant Function h n Class (beschränkte PQ) Pseudocode Sanders: Algorithmen I ) b ( q q qp 191 z z insert 10 11 12 13 js js js w w w h h p p g d d d r rz r b cg c a a c g h a 123456789 : j h: i ) then return ] i [ h ) ≤ ]) ] Element N @ @ April 17, 2009 : : 2 2 i / e e / i ( ( i ? ) ? [ w [ := @ ] h h 2 , n < ] [ / i siftUp insert ∨ ) i [ the heap property holds n h n ? 1 ; h ( ( ( except maybe at position = i ++ siftUp siftUp n swap if assert assert Procedure Procedure Einfügen Sanders: Algorithmen I 192 6 8 swap 9 4 13 7 6 8 compare 9 7 13 4 6 8 9 3 Element

April 17, 2009 : 17 4 −− Element : 7 ;n ] ) ] 1 1 n 6 [ [ ( result h h deleteMin 8 = := ] 1 1 9 [ return h result siftDown 3 4 Function Sanders: Algorithmen I 1 6 1 193 + 8 + i i swap 2 9 i = 4 := 2 j 13 7 m 6 and 8 is not a leaf i compare else i 2 i 9 // = 7 ] j := 2 13 4 m [ m h 6 8 heap property violated ≥ then // )] 9 ] m 3 1 ( 17 4 + i 2 7 [ sibling h 6 [ h 8 ≤ ∨ ] 1 i ]) ) 9 ) 2 m [ m [ 3 N ) h ( h then : 4 , m Element ∨ ] ] i ( i :

April 17, 2009 ( n [ m −− [ h Element sibling ( > h : 8∃ 1 ;n ] > ) ] then 1 ] 1 n + [ siftDown swap i [ ( siftDown [ i result n h the heap property holds for the subtree rooted at heap property @ subtrees rooted at h h 2 deleteMin = ≤ assert if if := i ] 2 1 [ assert assert if return h result siftDown Procedure Function Sanders: Algorithmen I 194 13 q z z 10 11 12 js js w w h h p p d q r r g cg d

April 17, 2009 a c 123456789 deleteMin deleteMin: Beispiel Sanders: Algorithmen I 195 . ) n . ) log n ( @ n O . log ) (

April 17, 2009 1 log pro Schicht. ( O ? ) O 1 dauert ( O dauert Höhe ist Zeit min dauert insert deleteMin Beweis: Lemma: Satz: Satz: Binäre Heap – Analyse Satz: Sanders: Algorithmen I 196 i ) ) i 1 ( ( ) N ) siftDown : 1 i ( + ) do i i 2 2 1 ( ( Konstruktion

April 17, 2009 downto @ 2 the heap property holds for the tree rooted at left child the heap property holds for the tree rooted at right child / ) then n i ( ? buildHeapBackwards buildHeap buildHeapRecursive buildHeapRecursive n the heap property holds for the tree rooted at := ≤ buildHeapRecursive assert buildHeapRecursive assert i i 4 for assert siftDown if Procedure Procedure Procedure Binärer Heap – Sanders: Algorithmen I 197 9 7 1 68 3 4 7 1 8 9 6 3 swap Konstruktion 1 8 9 3 compare 6

April 17, 2009 44 8 1 7 7 9 3 6 4 Beispiel: Binärer Heap – Sanders: Algorithmen I 198 0 j ' j ! ) 2 1 1 ( )& O ≥ ∑ j ( k 2 / O = 0 ! ! − ) − k n 2 k ( k O !< ∑ = ≤ 0 . ) k k n 2 2 ( / - O O O . = = @ . Insgesamt: n : 0 Konstruktion ) @ ) April 17, 2009 ! ! n log − ? − k log k ( ? = ( ! O .. k 2 0 k ∈ Sei !< ∑ ! ≤ Aufrufe von siftDown 0 buildHeap läuft in Zeit ! / Kosten je 2 O ! ! Satz: Beweis: Binärer Heap – In Tiefe Sanders: Algorithmen I 199 j − 2 1 ≥ ... ∑ j · + ) j − ... 2 3 + ≥ 8 ∑ j ... = ... / 1/16 + ... = 2 1/16 + ... = 1/8 1 + * j + − 4 2 / 2 1 ≥ ∑ j + + 2 2 j 1/8 + 1/16 + ... = 1/4 1/8 + 4 / 1 − * = 2 1 + 1 · 1 ≥ ∑ j 2

April 17, 2009 = =( = j − 1/4 + 3 1/4 + 1/8 + 1/16 + ... = 1/2 2 * · j 1 ≥ ∑ j 1/2 + 2 1/2 + 1/4 + 1/8 + 1/16 + ... = 1 * Ein nützlicher Rechentrick ______1 Sanders: Algorithmen I 200 ]) n .. 1 ? [ a ( do 2 aufsteigend ]) i [

April 17, 2009 a ) , ) ] 1 n ( 1 [ a downto ( log n heapSortDecreasing n ( −− := O n siftDown swap i buildHeap . for a Laufzeit: Sortieren durch Auswahl Frage: Wie sortiert man Andere Sichtweise: efﬁziente Implementierung von Procedure Heapsort Sanders: Algorithmen I 201 1 3 3 3 7 7 4 4 9 6 9 6 8 6 7 8 4 8 9 1 1 1 3 3 7 7 4 4 3 6 8 6 7 4 9 8 91 91 swap 1 1 6 8 3 3 7 7 4 4 9 6 9 8 68 compare 7 3

April 17, 2009 8 6 4 9 1 1 9 3 3 9 7 7 4 7 6 4 1 81 68 8 6 3 9 4 Heapsort: Beispiel Sanders: Algorithmen I 202 " ) ) n n n ) n log ( log log n B n n O ( ( ! Mergesort O O : O " ) ) n n " n 2 n log log ! log n B n ( ( O ! O Quicksort O O Mergesort Standardbibliothek ) ) ) n n n ↔ ) 1 ( log log log ++ n n n O ( ( ( Heapsort O O O

April 17, 2009 Quicksort ] ↔ Blockgröße) = Vergleiche [ B Cachezugriffe ( zusätzl. Platz Vergleiche E introspektives Quicksort der C Kompromiss: z. B. Heapsort Quicksort starten. Zu wenig Fortschritt? Umschalten auf Heapsort. Sanders: Algorithmen I k := ) h ( 203 ; key e k ≥ e ) h ( return key ; } return e { } ; n \ } e assert e { M \ ) := ,..., M 1 M Key e : { := $ ; k h M , := M } e := ∪ ; M { e M ∪ M ) Handle ) } M M := : n | e h M M := ( | min := min M ) e Handle $ ,..., : April 17, 2009 1 ) M e h e ( ( { ( ( return return merge decreaseKey build insert min deleteMin remove size Procedure Procedure Function Function Procedure Function Procedure Function 6.2 Adressierbare Prioritätslisten Sanders: Algorithmen I 204 minimale Spannbäume Routenplanung e.g., using addressable priority queue kürzeste Wege do // am wenigsten belastete Maschine → April 17, 2009 available “piece” to the solution : Jobs best piece priorities solution not complete add the update Hierarchiekonstruktion für Jarník-Prim Algorithmus für Scheduling Dijkstras Algorithmus für ! ! ! ! while Greedy-Algorithmus: Adressierbare Prioritätslisten: Anwendungen Beispiele: Sanders: Algorithmen I 7 9 9 7 205 8 1 ) 1 68 n ( 3 6 O 4 4 3 . . . e aktualisieren Vermittler-Objekte Vermittler → verweist auf Position von

April 17, 2009 ) Binäre Heaps e ( Element Unbewegliche proxy bei jeder Vertauschung Elemente bewegen sich. für alle Operationen ausser merge und buildHeap, die ) n Ausweg: Vermittler Rückverweis log ( Laufzeit: O (Ein) Problem: Dadurch werden Elementverweise ungültig. " Adressierbare Invariante: " brauchen. Sanders: Algorithmen I 206 ) ) ) n n n ) ) ) ) am. 1 1 1 n ) ( ( ( ( log log log 1 ( ( ( O O O O ( O O O O Fibonacchi Heap (Buch) ) ) ) ) n n n n ) ) ) ) n n 1 1 ( ( ( ( log log log log ( ( ( ( O O O O O O O O Binary Heap

April 17, 2009 remove decreaseKey min insert deleteMin size merge Operation build Adressierbare Prioritätslisten – Laufzeiten Sanders: Algorithmen I 207 für deleteMin, vergleichsbasiert. ) n log (

April 17, 2009 Ω Schlüssel (stay tuned) Beweis: Übung extern: Geht gut (nichtaddressierbar) parallel: Semantik? ganzzahlige Untere Schranke ! ! ! ! Prioritätslisten: Mehr Sanders: Algorithmen I 208

April 17, 2009 sind einfache, relativ efﬁziente Implementierung Binäre Heaps Häuﬁg benötigte Datenstruktur Addressierbarkeit ist nicht selbstverständlich ! ! ! Prioritätslisten: Zusammenfassung Sanders: Algorithmen I 209

April 17, 2009 7 Sortierte Folgen Sanders: Algorithmen I 210 ∞ } k ≥ e 19 : M 17 ∈ e { ∞ 13 min n e addressof Navigations−Datenstruktur := ) 57

April 17, 2009 k ( ≤···≤ 1 e 3 11 locate . mit 6 M n 2 e ,..., 1 e Annahme: Dummy-Element mit Schlüssel 5 Sortierte Folgen: „kennzeichnende“ Funktion: Sanders: Algorithmen I 211 r ∞ < ]= m ] 1 r < und [ + a ! k n [ ≤ // < a ] , k 1 ∞ < − − ] ! ! [ [ a a ]= , ] 0 [ k a m and := binärer Suche tatsächlich vorhanden sein? ,..., ! 1 ) k ∞ } + − k Assume else n / ]=[ ≥ 1 // m ∞ ≤ ] i Element r − [ := : a r r < k @ , ! !.. ] 1: [ 2 n a / ≤ ) + do .. )

April 17, 2009 then 1 ! 1 0 n r ] [ .. a + m + < [ 1 ( r n a ( 1 , ∈ so dass ? 0 i ≤ ( + r r { , ! k locate := ! := Müssen die Sentinels Variante von binärer Suche: invariant m if ) r k !, > return while ( ] r Find min [ a Übung: // Statisch: Sortiertes Feld mit Function Übung: bestimme Sanders: Algorithmen I 212 r ∞ < ]= m ] 1 r < [ + a ! n [ ≤ // a , k ∞ < − ] ! [ a ]= 0 [ a m and := binärer Suche ! 1 ) } + k Assume else n ≥ // m ≤ ] i Element r [ := : a r < k @ , ! ] 1: 2 n / ≤ ) + do .. )

April 17, 2009 then 1 ! 1 0 n r ] [ .. „halbiert“ sich in jedem Schritt a + m + < [ 1 ( ! r n a ( 1 , ∈ ? − 0 i ≤ ) ( + r r { n ! k locate := := invariant m if ) log r ( !, O return while ( Find min Beweisidee: Zeit: // Statisch: Sortiertes Feld mit Function Sanders: Algorithmen I 213 r ∞ < ]= m ] 1 r < [ + a ! n [ ≤ // a , k ∞ < − ] ! [ a ]= 0 [ a m and 15 := ! 1 ) = } + k k Assume else n ] ] ] ] ≥ // m ≤ ∞ ] ∞ ∞ ∞ i Element , r , , , [ := : a r 19 < 19 19 19 k , , , , @ , ! ] 1: 2 n 17 17 17 17 / ≤ , ) + do , , , .. )

April 17, 2009 then 1 ! 1 0 n r ] [ 13 13 13 13 .. , , , a + m , + < [ 1 ( r n a 11 11 11 ( 1 , 11 ∈ , , , , ? 0 i ≤ 7 7 7 ( + 7 r , , , , { ! k locate := 5 5 5 5 := , , , , invariant m if ) 3 3 3 3 r , , , , 2 2 2 2 !, , , , , return while ( ∞ ∞ ∞ ∞ Find min − − − − [ [ [ // Binäre Suche – Beispiel: [ Function Sanders: Algorithmen I 214 ) n log ( O ) } k ≥ e : M ∈ e {

April 17, 2009 := min ) k ( locate . M ( insert, remove, update, locate Dynamische Sortierte Folgen – Grundoperationen Sanders: Algorithmen I ∞ 215 19 ) ) 6 ) | 1 1 ( ( O O max 17 result | Zeit Zeit + ,..., n b 13 log ( ,..., a O // ,..., min Navigations−Datenstruktur 5 57 3 11 ) e → 2 h ( do

April 17, 2009 b ≤ next ) ) e b a → , ( a → h 56 ( result h := := h result.pushBack locate := Letztes Listenelement Erstes Listenelement return while result h : : rangeSearch Mehr Operationen Sanders: Algorithmen I min max 216 ) ) ) ) Δ n n n n ( O log log log log ( ( ( → O O O ) n ) ∞ 6 6 z log z ( O 19 ,..., ,..., y y 5 , , x Liste aufbauen 6 17 x ,..., 13 info ,..., w 5 w sortierte 5 )= Finger 6 z )=( y ( Navigations−Datenstruktur ,..., y 5 split 57 . ( 6 April 17, 2009 Abstand zu z = 3 11 Δ ,..., concat . y : Navigationstruktur für 6 , x x 2 rank, select, rangeSize build ,..., ,..., w w 5 (re) 5 ! ! ! Fingersuche: Zählen: zusätzlicher Parameter für insert, remove, locate,. . . Noch mehr Operationen Sanders: Algorithmen I 217 rangeQuery , locate geometrisch wachsende n M , (decreaseKey, remove). Dafür: log deleteMin -Updates. Aber:

April 17, 2009 insert, nur bulk nur insert, remove, ﬁnd. Kein nur langsamer als speziellere Datenstrukturen schnelles merge statische Datenstrukturen Hybrid-Datenstruktur oder Insgesamt: die eierlegende Wollmilchdatenstruktur. „Etwas“ Abgrenzung Sanders: Algorithmen I Prioritätsliste: Hash-Tabelle: Sortiertes Feld: 218

April 17, 2009 ... Datenbankindex Best-First Heuristiken Alg. Geometrie: Sweepline-Datenstrukturen ! ! ! ! Sortierte Folgen – Anwendungen Sanders: Algorithmen I 219 sort // ) new bin ( e ≥ insert . ) B b ( then used bins sorted by free capacity e // > ) b ( ) b s ( free with smallest free

April 17, 2009 : B by decreasing element size B s ∈ ) into bin ∈ | ∈ b s e | b e binPacking ¬∃ log | locate insert if s SortedSequence | ( : O B foreach Procedure Anwendungsbeispiel: Best First Bin Packing Qualität: „gut“. Details: nicht hier Zeit: Sanders: Algorithmen I ∞ 19 220 19 17 17 13 11 11 13 7 7 . ) 5 5 k k 3 ≤ > 3 2 2 Schlüssel Schlüssel , ) r ,!, k

April 17, 2009 einer sortierten Folge. =( v erreichbare Blätter haben erreichbare Blätter haben ! r Spalt-Schlüssel, linker Teilbaum, rechter Teilbaum über Invariante: über Blätter: Elemente Innere Knoten 7.1 Binäre Suchbäume ( Sanders: Algorithmen I 221 ) verwendet. Schnittstelle 19 mit der sortierte Folge 17 13 11 Implementierung 7 5 innere Knoten Elemente

April 17, 2009 3 “ wird oft als Synomym für 2 Element im Prinzip verzichtbar Suchbaum (Aber das vermischt (eine) „ Dummy Oft speichern auch ! ! ! Varianten, Bemerkungen Sanders: Algorithmen I ∞ 19 222 19 > 17 17 13 > 11 11 13 < 15? 7 7 5 5 3 erreichbaren Listenelemente. 3 x 2 2 k ) k ) ≥ < x als Wegweiser. left right x sind → → sind X next x x , , X k k → ( ( von x )

April 17, 2009 von x die Menge aller von , k then return X locate locate ( then k links rechts Sei then ≥ x x locate ) k if return return else return ≤ is a leaf ( k x else if if Listenelemente Function Idee: Benutze Spaltschlüssel locate Invariante: Listenelemente Sanders: Algorithmen I ∞ 19 223 19 > 17 17 13 > 11 11 13 < 15? 7 * 7 n 5 5 log ) 3 = 3 2 Tiefe 2 ) ) x als Wegweiser. left right ) x → → k n next ( x x , , k k → ( ( Tiefe x )

April 17, 2009 x . , ) k then return locate locate ( then k Tiefe perfekt balanciert, d. h. then ( ≥ x x O locate if return return else return ≤ is a leaf k x else if if Bester Fall: Schlechtester Fall: Function Laufzeit von locate Laufzeit: Idee: Benutze Spaltschlüssel Sanders: Algorithmen I 224 $ e v e u T der Vorgänger u e $ e insert u T gefundenes Element, $ e T u . Sei $ )

April 17, 2009 e e ( v e locate e T insert u $ e Zunächst wie Naives Einfügen Sanders: Algorithmen I ∞ 225 19 19 17 17 13 13 11 11 11 insert ∞ 19 19 17 17 13 13 13

April 17, 2009 insert ∞ 19 19 17 17 17 langsam

∞

insert Problem: Der Baum wird beliebig unbalanciert. " Beispiel Sanders: Algorithmen I

19 19 226 Suchbäume. binäre . . b -Bäume ) und b balancierte , a

April 17, 2009 a : ( ) n schwer aufreichzuerhalten n a log ( log O ≈ Grad zwischen ≈ Tiefe nicht hier (Variantenzoo). Suchbäume balancieren Sanders: Algorithmen I ﬂexibler Knotengrad: perfekte Balance: ﬂexible Tiefe ∞ 227 17 7 1113 5 gleicher Tiefe! 57 ) 3 11 13 17 56 2 3 19 für 2 19 1 b .. April 17, 2009 a , (Grad b Grad -Bäume .. ) 2 r b , a ! Grad ( Listenelemente (wie gehabt). Alle mit ∞ 7.2 Sanders: Algorithmen I Wurzel: Blätter: Innere Knoten: ) ∞ 228 ABHandle of outdegree // 17 Sequence 7 1113 5 : 57 Key Key, children 3 11 13 17 of of Handle ] 2 3 19 1 of 2 19 − ] b b to ABItem or Item .. .. 1 1 [ [ Sequence ∞ : b mit ..

April 17, 2009 ] i ]= [ :1 Pointer s 1 Array Array : | : : + ≤ splitters d e ( [ s < , erreichbar ] ] ∞ i 1 [ children splitters children | − c ABHandle ABItem − = = = i s d c [ s ]= über 0 [ ⇒ Class Class e Invariante: Items s Sanders: Algorithmen I 229 ) r height , k ! ( ∞ // .locateRec k r Element ≥ $ of k ) N return 1: − a Handle 2 ): ≥ ) 6 b Key , : N k head ( April 17, 2009 !. 2: Element 5 , ≥ N of 56 locate a ( 1: List : = 56 ABItem( ABTree Locate the smallest Item with key : = Function // r ! height Class Initialisierung Sanders: Algorithmen I 230 23 2 22 2 20 2 STree STL map (2,16)-tree orig-STree 18 2 LEDA-STree n 65536 16384 4096 1024 256 100

1000

Handle Time for locate [ns] locate for Time ): N // ) N ] 1 i : ): [ c − h h Key } , ] : i k [ Key, k s ( : return k ≤ ( next k : → d Then ] i locateRec( .. k [ ) 1 c k

April 17, 2009 → ≥ ∈ ] i e i [ { c → ] analog binäre Suchbäume then i min [ 1 c ABItem::locateRec ABItem::locateLocally return if else return = locateLocally( h := else if return i Invariante: Function Function Locate Sanders: Algorithmen I 231 ? b log → b Übung: C 1 2 + n a . a log B ≥ + 1 . 1 1 und

April 17, 2009 ≤ eine ganze Zahl ist 2 2 = h 1 + h − n ≥ h = a a 2 Blätter. Blätter. height log ) 1 1 : : ≥ 1 1 height − + 1 + h 1 n a > = + 2 height ≤ n n n · h ≥ b ( Wurzel hat Grad Innere Knoten haben Grad ⇒ Fall ⇒ Beweis: Fall Lemma: O Locate – Laufzeit Rundung folgt weil Es gibt Also Sanders: Algorithmen I . . . b/2+ b/2+ . . . 232 x+1 . . . b/2 b/2 ...... b b x

April 17, 2009 ) , ) then 1 e e ( ( 1 in 2 Knoten mit Graden + als neuen Splitter in Vorgänger b u + ) ( e b ? ( insert = Weiter oben einfügen, spalten ... ggf. neue Wurzel spalte d . u insertBefore if Finde Pfad Wurzel–nächstes Element !. füge key Procedure Einfügen – Algorithmenskizze Sanders: Algorithmen I ∞ 233 19 ∞ 17 17 7 1113 7 1113 5 5 5 7 11 13 17 4 5 7 11 13 17 4 4 3 3 3

April 17, 2009 2 19 2 3 19 2 2 19 Einfügen – Beispiel Sanders: Algorithmen I ∞ 234 ∞ 17 15 15 15 13 13 17 17 7 11 19 7 1113 5 5 5 7 11 13 17 3 19 3

April 17, 2009 23 2 3 19 2 5 7 11 2 19 Einfügen – Beispiel Sanders: Algorithmen I ∞ ∞ 235 19 17 17 19 19 15 15 15 15 13 13 13 17 17 11 7 1113 5 5 7 3 3 19

April 17, 2009 23 23 2 5 7 11 2 5 7 11 Einfügen – Beispiel Sanders: Algorithmen I ∞ ∞ 236 19 19 17 17 19 15 15 15 15 13 13 17 17 11 11 5 5 7 13 7 13 3 3

April 17, 2009 23 2 3 19 2 5 7 11 2 5 7 11 Einfügen – Beispiel Sanders: Algorithmen I 237 ∞ ∞ 12 12 5 5 3 5 3 25 23 r r 2 23 ∞ 12 12 r

April 17, 2009 5 5 = t , 3 2 23 = k Einfügen – Beispiel Sanders: Algorithmen I 238 12 3 1 − a 25 2 ≥ b a ⇔ split a = ! ≥ C a C 2 12 2 1 5 B 2 + = b

April 17, 2009 C B 23 1 )+ 1 2 − a 12 2 5 ( b b+1 B 23 Weil Nach dem Spalten müssen zulässige Items entstehen: Einfügen – Korrektheit Sanders: Algorithmen I 239 Nachfolgern. Nachfolger. 1 b + b nach oben fort. Aber wir speichern Kapazität für . stapel speichert Pfad. von unten

April 17, 2009 nach unten Rekursions einfacher, schneller, Speicherverwaltung! nur Zeiger Lösung: Baue nie explizit temporäre Knoten mit Einheitlicher Itemdatentyp mit Spalten pﬂanzt sich ! ! ! Einfügen – Implementierungsdetails Sanders: Algorithmen I 240 ) ) 6 t , r ) 5 , 6 ,! k Element 5 ( : e height ( , e ( ABItem

April 17, 2009 ++ insertRec . allocate r ABTree::insert null then := := height r ) 8= t , t k if ( Procedure Einfügen – Pseudocode Sanders: Algorithmen I ])) d ABHandle − × 1 + 241 Key b .. ): 1 [ $ base c , ) // ] recurse d this node Element // new child − null new splitter // b of , ])) i .. [ // split ⊥ ) 1 c ) ( [ List , $ // ,! s e : 1 ( ( ! null , − , 6 ] h N , return ⊥ 1 : ( e ; 6 ( ) h − ] ABItem 1 d d [ [ c + s insertBefore d , $ ,!. ) c ,..., ,..., insertRec Element, , ] e ] ] $ allocate i i ( : [ s 1 [ , ] c ( s → e , , ( d + ] key t ] i k ( , := [ b , b ] − ) ] c .. .. @ 1 1 d 1 := null then return d 2 d , ) ) := − / c t − + e ) − i = , ) , −

April 17, 2009 i t ( [ b [ s k 1 , t 2 [ c 2 ( s ( $ k s ( if + + + ( b b b [ ( [ ,..., $ ,..., $ ? ] then then ] c s 1 1 b [ 1 [ ABItem::insertRec := c s := := 5 5 s return d c < = locateLocally d h := := $ $ := c s else if if else i Function Sanders: Algorithmen I 4 c 3 3 c c 2 c 242 1 2 c k 2 c k 1 1 c k v 3 fuse c 4 2 c c 3 balance c k 1 2 2 c c k 1 v k 1 c v ) u , $ u ( u balance $ u e ) ) u

April 17, 2009 e then , in Vorgänger $ ( then ) a u 1 e ( ( > ) − e d a ( fuse Weiter oben splitter entfernen ... ggf. Wurzel entfernen . remove $ u = else ﬁnde Nachbarn if d . u remove entferne key if !. Finde Pfad Wurzel– Procedure Entfernen – Algorithmenskizze Sanders: Algorithmen I ∞ 243 23 23 r ∞ i 23 $ $ s c s c r i ∞ s c 3 r 2 3 2 3 2

April 17, 2009 ∞ 5 5 k 3

Entfernen – Beispiel Sanders: Algorithmen I r

23 2 244 ∞ ∞ 19 balance 17 17 7 1113 7 1113 5 5 57 3 11 13 17 3 11 13 17

April 17, 2009 23 2 3 19 2 5 7 2 19 Entfernen – Beispiel Sanders: Algorithmen I 245 ∞ ∞ 19 balance 17 13 7 1113 5 5 3 11 13 17 3 11 13 17

April 17, 2009 2 3 7 11 17 23 2 5 7 2 5 7 Entfernen – Beispiel Sanders: Algorithmen I 4 c 3 3 c c 2 c 246 1 2 c k 2 c k 1 1 c k v 3 fuse c 4 2 c c 3 balance c k 1 2 2 c c k 1 v k 1 c v 1 − a 2 ≥

April 17, 2009 b ⇔ b ! ≤ : Kein Problem ) 1 − fuse a +( hatten wir schon! müssen zulässige Items entstehen: a Balancieren Entfernen – Korrektheit Nach Sanders: Algorithmen I 247 ) n a log b ( O )= ) 1 ( Tiefe · O b ( ⊆

April 17, 2009 O } b , a { für ) n log ( O Einfügen und Entfernen – Laufzeit = Sanders: Algorithmen I ) m , ] ) $ m d , .. $ 1 c [ ) $ , $ c ) s , $ ] ( m := r 1 248 ) − := )) − $ d ) s Element d d m → .. → of , ] → 1 ] ] ) [ $ dispose 1 ] $ 1 c ; d 1 s ] List + ( .. + 1 : i [ + → 1 i ) [ [ i i c ] c := [ . ( c ,! ) + 1 $ c , r , d N 6 , m ] + c : c [ i i [ $ := [ → s h c r ) c , 5 , → ] → ; ] , i , ] N ] [ r c 1 s ) 1 c : 1 , Key ) i ,! − := c + → → ( : $ + $ 1 i ] r i ] [ d k i [ i fuse balance Key [ [ − c ( → c .. ] c , , : c ] h 1 1 ( then s s ; removeLocally ( i , ] [ k ) F ) i ] i e k ( then −− c + [ − ] 2 i ( ( , → → c ,! m / d 1 ]) d s [ m $ ] ] i then [ $ .. [ .. 1 1 $ d )= s > 1 c a 1 ) then // s e E → ( ( k + + D D then ] b + := $ ( + height i i i < ] [ [ [ i c , := i d → i [ [ D D [ c c c ≤ d k ] concatenate concatenate c s s ( ( dispose m ( i ( $ height = [ removeRec := d i c := → := remove := := ∧ $ ( $ $ ] ] ] then c d removeLocally !. s if else // if i 1 1 → 2 ABItem::removeLocally ABTree::remove ABItem::removeRec [ ] 1 key c i − = − [ if c if = d d d locateLocally . .. .. h r i i −− [ .removeRec [ := r i c if else if s d Procedure Procedure Procedure .

April 17, 2009 neu her man leitet -Bäume ) b split, balance, fuse Tiefe, Knotengrade Grundideen Invarianten , a ! ! Gar nicht! Man merkt sich: Wie merkt man sich das? Implementierungsdetails Etwas kompliziert. . . Den Rest ( sich nach Bedarf Sanders: Algorithmen I 249 ! ) 6 " ) n n m n ( max O log log ( n O ! ,..., O b Zeit Laufzeit Zeit ,..., a Übung! ,..., min 5 | M | = Liste aufbauen) m : ) b |≤ , a N ( | sortierte = April 17, 2009 n : sei : nicht hier. ) rangeSearch M , , split N , ( : max , nicht hier. Idee: z. B. Fingersuche merge Idee: Ganze Teilbäume umhängen min build hatten wir schon 7.3 Mehr Operationen concat (Navigationstruktur für Sanders: Algorithmen I 250 it an remove und insert

April 17, 2009 7.4 Amortisierte Analyse von Grob gesagt: Abgsehen von der Suche fällt(summiert nur über konstant alle viel Operationsausführungen). Arbe nicht hier. Sanders: Algorithmen I 251 gold plating mehr (schnelle) Operationen. "

April 17, 2009 Idee: zusätzliche Infos verwalten 7.5 Erweiterte (augmentierte) Suchbäume wenn diese Operationen nicht wichtig sind. Nachteil: Zeit- und Platzverschwendung Sanders: Algorithmen I 252 , ∞ insertAfter , insertBefore -Bäumen? 17 , ) b 7 1113 5 , a ( remove des Elements kennt.

April 17, 2009 57 3 11 13 17 handle 2 3 19 2 19 was speichert man bei Frage: Anwendungen: schnelleres wenn man ein 7.5.1 Elternzeiger Idee (Binärbaum): Knoten speichern Zeiger auf Elternknoten Man spart die Suche. Sanders: Algorithmen I 253 hbar. ) k !, h ( ? select ) bestimmen. -Bäumen ) bestimmen. b leftSize b e .. , − a a ( k ) , then return r k ( , k h

April 17, 2009 ( > select eines Elements ) leftSize n selectRec -th Element in subtree rooted at k → log Was ist anders bei Rang Größe eines Range ( h O if else return return Zeit: Function Übung: Übung: Übung: // Idee (Binärbaum): speichere wieviele Blätter von links(Etwas erreic anders als im Buch!) 7.5.2 Teilbaumgrößen Sanders: Algorithmen I ∞ 1 254 2 6 < 7 5 13 1 = i + 17 6 4 4 < 6 4 1 = i ≥ + 0 2 11 6 + 4 ≥ 4 4 7 = i 7 1 0 = i 5 19 5 7 11 13 17 2

April 17, 2009 3 3 1 2 size select 6th element select left subtree 2 19 7.5.3 Beispiel Sanders: Algorithmen I 255 sortierten zusätzliche Operationen Ausführungszeit "

April 17, 2009 erlauben viele efﬁziente Operationen auf . logarithmische Folgen Der schwierige Teil: logarithmische Tiefe erzwingen. Augmentierungen Oft Suchbäume ! ! ! ! Zusammenfassung Sanders: Algorithmen I 256 Daten ) U Datenstrukturen mehrdimensionale , loglog U ( .. externe O 1 Zeichenketten

April 17, 2009 Array mit Löchern " -Bäume sind wichtig für ) b Grundoperationen in Zeit , a " Verallgemeinerungen: Ganzzahliche Schlüssel aus Karteikasten ( ! ! ! ! Mehr zu sortierten Folgen Sanders: Algorithmen I 257 ) Compilerbau " scheduling Probleme "

April 17, 2009 “touristische” Frage: Werte und arithmetische Operationen ... Soziale Netzwerke (Freundschafts-, Zitier-, Empfehlungs-,. . . Aufgabenabhängigkeiten Zugverbindungen (Raum und Zeit) Straßen- oder Computernetzwerke 1736 fragt L. Euler die folgende ! ! ! ! ! ! ! 8 Graphrepräsentation Sanders: Algorithmen I t u 1 258 2 2 y x 1 3,3 5 K K 1 1 1 1 G z w x 1 1 u 2−2 s v s t wv U w 1 u u v self−loop H undirected bidirected wv wv Operationen

April 17, 2009 Repräsentation Listen triviale Diskussion Implizit Verkettete Matrizen Felder Was zählt sind die Eine ! ! ! ! ! ! ! Graphrepräsentation Sanders: Algorithmen I 259 Konvention unverbindliche = : ) z E , ()&' y

April 17, 2009 Kanten , , x , w , V v Buchstabenzuordnungen ()&' . Knotenpaare (manchmal Knotenmengen der Größe 2) , Knoten u E , t ∈ , =( s | e | G E V | | Manchmal werden ganz andere Buchstaben verwendet. Im Zweifel immer genau sagen was was ist. = = ! ! Kanten Das gilt für die ganze theoretische Informatik Knoten: WICHTIG: m Graph Notation und Konventionen n Sanders: Algorithmen I 260 3 4 2 1 Graphen bigerichtete 3 gerichtete Graphen

April 17, 2009 2 4 → Graphen durch 1 wir konzentrieren uns auf gerichtete Graphen ungerichtete Ungerichtete " Meist repräsentieren wir Sanders: Algorithmen I t u 261 x v z w s y für alle Operationen ) ,

April 17, 2009 v Zeit) ) n Gegeben + Ausgabegröße m ( ( O O ﬁnde ausgehende Kanten. ( Dynamische Graphen Knoten/Kanten einfügen/löschen Ziel: Operationen Grundoperationen Statische Graphen Sanders: Algorithmen I Navigation: Konstruktion, Konversion und Ausgabe t u 262 3 5 2 4 x v 6 1 4 3 ? z w 5 8 6 s y 7 ? E ∈

April 17, 2009 ) x , z ﬁnde ( gehende Kanten ein Weitere Operationen Sanders: Algorithmen I Kantenanfragen: Zugriff auf assoziierte Information mehr Navigation: 263 fen . 6 ) w , , u ( , ) u , Konvertierung w , ( , ) w , v ( , ) v ,

April 17, 2009 u ( ⇔5 Übung: isolierte Knoten suchen I/O u gut für kompakt Fast keine nützlichen Operationen ausser alle Kanten durchlau wv − + + Beispiele: Kruskals MST-Algorithmus (später) Folge von Knotenpaaren (oder Tripel mit Kantengewicht) Kantenfolgenrepräsentation Sanders: Algorithmen I 264 1 − n .. 0 oder m 7=m+1 ] v [ V 1 − + ] 1 m + v [ 1 113577 233424 n 5=n+1 V V E speichert )= v ] ( Ziele 1

April 17, 2009 4 + n [ V speichert 3 2 E nach Startknoten n -Eintrag 1 .. 1 speichert Index der ersten ausgehenden Kante = V Beispiel: Ausgangsgrad Dummy Kantenfeld Adjazenzfelder gruppiert V Sanders: Algorithmen I 265 m 7=m+1 place count // // preﬁx sums // v 233424 1 113577 n 5=n+1 ]] = u [ ] E V 1 V N − ]++ of v 4 [ u −− ] [ [ 1 V ) E V + += ] n 3 2 do do v .. [ 1 [ V EdgeList 1 ( do EdgeList EdgeList 1

April 17, 2009 Adjazenzfeld Array KSort ∈ ∈ + : ) ) n ) v v 6 → E , , 0 to , u u ( ( V ( adjacencyArray ,..., := 2 0 v 5 = V foreach return foreach for Function Kantenliste Zur Erinnerung: Sanders: Algorithmen I 266 m 7=m+1 233424 a b c d e f 1 113577 n 5=n+1 w E V (oder mehrere Felder) 4 f d e 3 2 c b a 1

April 17, 2009 umgedrehten Graphen speichern wird Feld von Records E explizite Endindizes wird Feld von Records (oder mehrere Felder) V einfach neu aufbauen Operationen für Adjanzenzfelder Sanders: Algorithmen I Batched Updates: Eingehende Kanten: Kanten löschen: Knoteninfos: Navigation: Kantengewichte: 267

April 17, 2009 speichert (ggf. zusätzlich) alle Kanten. E H Hashtabelle Kantenanfragen Unabhängig von der sonstigen Graphrepräsentation Sanders: Algorithmen I 268 2 3 21 n 1 34 4 1 2 4 m adjazenter Kanten für jeden Liste n von Kanten von Kanten (ordnungserhaltend)

April 17, 2009 2413424123 1 1 Löschen Einfügen 3 4 2 einfaches einfaches mehr Cache-Misses mehr Platz (bis zu Faktor 3) als Adjazenzfelder + + − − 1 speichere (doppelt) verkettete Adjazenzlisten Knoten. Sanders: Algorithmen I 0 1 2 3 3 0 2 2 2 1 2 2 2 2 0 269 0 0 0 first first deg deg out in out in 0 V list 0 0 0 rev from to 0 0 0 0 0 0 0 0 0 out list in list 00 0 E list

April 17, 2009 (2,1) (2,3) (0,1) (0,2) (1,2) (1,3) für Knotenupdates Kantenobjekte (in globaler Kantenliste) Zeiger auf Umkehrkante Knotenlisten Ausgehende Kanten ! ! ! ! Adjazenzlisten aufrüsten Sanders: Algorithmen I 270 n

April 17, 2009 Listen vermeiden Ziel: schnell, kompakt. benutze Entwurfsprinzip: Make the common case fast ! ! ! Möglicher Ausweg: Trennung von Algorithmus und Repräsentatio Software Engineering Alptraum Anpassen der (Graph)datenstruktur an die Anwendung. Customization (Zuschneiden) Sanders: Algorithmen I 271 ! ) m ( Zeit O ) w // ( Adjazenzarray! // Stack : } 0 droppable.push ]= v do [ then E 0 ∈ )) ) E ]= w do , , inDegree −− w ] v /0 [ V : ( pop w . is a DAG iff the input graph is a DAG [ V 8=

April 17, 2009 =( G ∈ dropped G edge v ( ++ = { inDegree | = inDegree if V droppable := 0 | droppable isDAG := dropped v foreach invariant droppable return while compute array inDegree of indegrees of all nodes dropped Function Beispiel: DAG-Erkennung Sanders: Algorithmen I 272 s Algorithmus j nach i Strassen ] E ∈ : ) j k , i ≤ und Graphentheorie -Kanten-Pfade von k ) = [( dichte Graphen j # , i = (

April 17, 2009 ij A sonst. Übung: was bedeutet “sehr dicht” hier? C . k with A n lineare Algebra Kantenanfragen × = n } Matrixmult. für Potenzberechnung Beschleunigungstechniken C inefﬁzient 1 ) , k 0 { verbindet einfache platzefﬁzient für sehr langsame Navigation platz log ∈ ( − + + Übung: zähle Pfade der Länge Wichtige Beispiel: A Adjazenz-Matrix O Matrixmultiplikation in subkubischer Zeit, z. B., Sanders: Algorithmen I ++ −− 273 ⇒ .   1 2 c c   = )   H 0 1 2 x x 8= ij   B :   ) 2 j 0 , i (

April 17, 2009 ein DAG ist? c G 1 0B habe zwei Zusammenhangskomponenten G B = = G E   , Bx n .. 1 =( G Übung: Was wenn tausche Zeilen und Spalten so dass Nehmen wir an, Sei Problem: löse Beispiel wo Graphentheorie bei LA hilft Sanders: Algorithmen I 274 mittels dieser Repr. direkt R ⊆ ]

April 17, 2009 b , a [ Algorithmen Repräsentation möglicherweise sehr dichter Graphen Kompakte Implementiere Implizite Repräsentation Beispiel: Intervall-Graphen Knoten: Intervalle Kanten: zwischen überlappenden Intervallen Sanders: Algorithmen I 275 } 1 , 0 { end point // H /0 8= 1 ] j Kanten! ++ b := , " j 2 a n [ ! ∩ overlap O ] i 0 b , ; overlap i then a L [ } : SortedListOfIntervalEndPoints) : ] : n L b H return ] , j n

April 17, 2009 0 −− do b a [ , = j L a Intervalle von links nach rechts. Die Anzahl [ ∈ , ] ,..., p overlap i is a start point ] 1 1 b Algorithmus für bis zu p overlap , isConnected( b i ) , a if else if 1 n [ a [ durchlaufe { GG log remove ﬁrst element of return foreach n = = ( Idee: Übung: Zusammenhangskomponenten ﬁnden E Function Zusammenhangstest für Intervallgraphen überlappender Intervalle darf nie auf Null sinken. O V Sanders: Algorithmen I 276 werden gebraucht?

April 17, 2009 gut für statische Graphen ﬂexibler aber auch teurer arrays Operationen " ? Pointer Matrizen eher konzeptionell interessant Adjazenz Welche Wieoft ! ! ! ! ! Graphrepräsentation: Zusammenfassung Sanders: Algorithmen I 277 nalgorithmus

April 17, 2009 Ausgangspunkt oder Baustein fast jedes nichtrivialen Graphe 9 Graphtraversierung Sanders: Algorithmen I 278 cross backward forward tree

April 17, 2009 s Graphtraversierung als Kantenklassiﬁzierung Sanders: Algorithmen I 279 cross forward backward tree 3 g s 2 f e

April 17, 2009 Pfaden erreicht. Berechne Abstände Startknoten 1 d c b erreichbaren Knoten kurzen s 0 s mit möglichst der alle von Baue Baum von 9.1 Breitensuche Sanders: Algorithmen I 280 cross forward tree backward 3 g f 2 e kürzeste Wege Problems

April 17, 2009 1 d c b eines Knotens deﬁnieren 0 s (auch wenn Reihenfolge egal) (ggf. begrenzte Suchtiefe) Einfache, efﬁziente Graphtraversierung Einfachste Form des Umgebung ! ! ! Breitensuche Sanders: Algorithmen I 281 cross forward tree backward aufbauen 3 g 2 f e Schicht für Schicht

April 17, 2009 1 d c b 0 s Algorithmenidee: Baum Breitensuche Sanders: Algorithmen I 282 aktuelle Schicht $ cross forward Q tree backward // 3 g Q 2 f e

April 17, 2009 do 1 56 d c b ): $ s ( 8= Q 6 Q bfs := s 5 Q exploriere Knoten in merke dir Knoten der nächsten Schicht in 0 s := Q while Function Sanders: Algorithmen I 283 tree parent g s ⊥ ]= ]= s v [ [ f e

April 17, 2009 d c b speichert Vorgänger. s parent noch nicht erreicht: parent Startknoten/Wurzel: parent ! ! Feld Repräsentation des Baums Sanders: Algorithmen I ) } ∞ ∪{ 0 284 N s } u ) of := s w := 0 ] ] ( s s [ scan [ d // from next layer parent ! unexplored // = NodeArray // ( v , × V ) u current, next layer ∈ // := ; w ) } v : ( NodeId ) ∞ w NodeId; parent , of ∪{ v ( of 0 { N then } do ; parent v = do 1 of ⊥ { 56 E NodeId + ∪ 8= $ ! NodeArray ∈ BFS )= ( of Q Q v ) NodeArray ) := ( // v ] : ): do , := v 56 $ Set [ u , contains all nodes with distance ( $ : Q ) d Q NodeArray

April 17, 2009 ⊥6 d while Q : ∈ Q parent , 56 ( 6 u ∞ NodeId if = := : ∞ ,..., $ ) to s $ ( Q parent foreach Q , 5⊥ ( , 6 bfs ,..., s = := 0 Q 5 ∞ ( invariant foreach ! 5 = = return Q for d parent Function Sanders: Algorithmen I 285 $ Q $ n Q und Q der Größe Q −→ $ ←→

April 17, 2009 Q ; ein Feld $ Q ausrollen × 1 −→ Q Q loop Beide Stapel in Schleife Zwei Stapel ! ! ! Repräsentation von Sanders: Algorithmen I 286 Übung? Übung: ausprobieren?

April 17, 2009 einfacher weniger evident einzelne FIFO Queue −→ $ Efﬁzient (?) „Oberﬂächlich“ Korrektheit Standardimplementierung in anderen Büchern Q , = − + ! Q BFS mittels FIFO Sanders: Algorithmen I 287 g c ef d b s

April 17, 2009 cross forward tree backward 9.2 Tiefensuche Sanders: Algorithmen I 288 . u ) w , v coming from a root and grow ( v s make ) along the incoming edge E // Explore v , ) a new DFS-tree rooted at it. // V w , // v ( =( G ) traverseNonTreeEdge return from ) // w do then , w then NodeId v E : ( init April 17, 2009 v ∈ , ; ) ) u traverseTreeEdge mark DFS ) v ( w s , do , , s u ) v s ( s ( is marked ( V ( DFS w ∈ s all nodes if else mark root DFS is not marked s backtrack foreach if mark Procedure foreach un Tiefensuchschema für Sanders: Algorithmen I 289 NodeId of f f NodeArray g g c c : ⊥6 e e v s ,..., := ] := 5⊥ ] d d b b s w [ [ = s s parent parent : ) w

April 17, 2009 , v ( tree parent tranverseTreeEdge(s,b) mark b dfs(s,b) mark s root(s) dfs(s,s) : ) s ( root init: parent traverseTreeEdge DFS Baum Sanders: Algorithmen I 290 f f f f g g g g c c c c e e e e d d d d b b b b s s s s

April 17, 2009 backtrack(g,f) backtrack(e,c) traverseNonTreeEdge(g,b) traverseTreeEdge(g,f) mark(f) dfs(g,f) backtrack(e,g) traverseNonTreeEdge(e,f) mark(c) dfs(e,c) traverseTreeEdge(e,g) mark(g) dfs(e,g) backtrack(b,e) traverseTreeEdge(e,c) backtrack(s,b) mark(e) dfs(b,e) traverseTreeEdge(b,e) dfs(s,b)

Sanders: Algorithmen I 291 f f g g c c e e d d b b s s

April 17, 2009 traverseNonTreeEdge(d,f) backtrack(s,d) traverseNonTreeEdge(d,e) mark(d) dfs(s,d) traverseTreeEdge(s,d) backtrack(s,s)

Sanders: Algorithmen I 292 g c 6 ++ ++ sortiert ≺ n ef .. dfsPos . dfsPos ] := ] := v ] [ 1 : 1 s w [ [ d b 7 = dfsNum s dfsNum dfsNum 12345 < ] : u ) [ w

April 17, 2009 , v ( cross forward tree backward dfsNum ⇔ : v : ≺ ) u s ( root init: dfsPos traverseTreeEdge DFS Nummerierung Knoten auf dem Rekursionsstapel sind bzgl., Beobachtung: Sanders: Algorithmen I 293 g c 3 ++ ef n .. ﬁnishingTime d b 1 : 1 6 = := ] v [ s 75421

April 17, 2009 finishTime cross forward tree backward : ) v , u ( backtrack init: finishingTime Fertigstellungszeit Sanders: Algorithmen I 294 is w marked yes yes no yes < ] cross ] v w [ [ backward finishTime yes yes no yes finishTime < ] forward ] w v tree [ [

April 17, 2009 s dfsNum yes yes no no dfsNum ) w , v ( tree type cross forward backward Kantenklassifizierung bei DFS Sanders: Algorithmen I 295 ) ] v v ( [ t < ) u ( t : finishTime E − n ∈ , ) := v ) , v u DFS finded keine Rückwärtskante. ( ( t ∀

April 17, 2009 ⇔ kreisfrei (DAG) topologische Sortierung ist eine Satz: G Topologisches Sortieren mittels DFS d. h. In diesem Fall liefert Sanders: Algorithmen I 296 topologische eine ] cross v . [ ) v ( t < ) u finishTime ( backward t − : Rückwärtskante. n DFS finded keine Rückwärtskante. E ∃ := forward ⇔ ∈ ) tree ) v s ( April 17, 2009 v t , u ( ∀ Annahme ”: , d. h. ⇒ kreisfrei (DAG) G Sortierung In diesem Fall liefert Satz: Topologisches Sortieren mittels DFS Beweis “ Zusammen mit Baumkanten ergibt sich ein Kreis. Widerspruch. Sanders: Algorithmen I 297 ] w [ topologische finishTime eine ] > v ] . [ v ) [ v ( t < ) u finishTime ( finishTime t − : : n DFS finded keine Rückwärtskante. E E := ⇔ ∈ ∈ ) ) ) v ( April 17, 2009 v w t , , u v ( ( ∀ ”: , d. h. ⇐ kreisfrei (DAG) ⇒∀ G &'() finishTime definiert umgekehrte topologische Sortierung. Sortierung In diesem Fall liefert Satz: Topologisches Sortieren mittels DFS Beweis “ Keine Rückwärtskante Kantenklassifizierung ⇒ Sanders: Algorithmen I 298 i Übung h , g b , f . , starke 6 d u , c ,..., v Algorithmen II 5 a −→ Pfad ∃ . bezeichnet man als und i ∗ 6 ↔ v mit ∗ von g ↔

April 17, 2009 ,..., ist Äquivalenzrelation u 5 ∗ ↔ f h b Pfad ∃ de c falls v Äquivalenzklassen a e ∗ ↔ DFS-basierter Linearzeitalgorithmus Die Betrachte die Relation Starke Zusammenhangskomponenten Zusammenhangskomponenten u Beobachtung: Sanders: Algorithmen I 299

April 17, 2009 Knotens aus einer Komponente bleibt diese zusammenhängend (ungerichtet) Planaritätstest (läßt sich der Graph kreuzungsfrei zeichnen?) Einbettung planarer Graphen 3-zusammenhängende Komponenten 2-zusammenhängende Komponenten: bei Entfernen eines ! ! ! ! Mehr DFS-basierte Linearzeitalgorithmen Sanders: Algorithmen I cross 300 backward forward tree s

April 17, 2009 kanten DFS Vorwärts ←→ Grundlage vieler Algorithmen keine explizite TODO-Datenstruktur (Rekursionsstapel) kürzeste Wege, „Umgebung“ nichtrekursiv keine ! ! ! ! ! pro DFS BFS pro BFS: Sanders: Algorithmen I 301 . 3.0 km , v } v nach R s nach s → . E ) : i Repräsentation der kürzesten Pfade e c ( ) c 1 E , = k i ist Pfad von V ∑ V p

April 17, 2009 : ∈ =( = : ) v ) G p 6 . ( k s c e { des kürzesten Pfades von für alle Graph ) v min ,..., ( 1

µ e = 5 : ( ) c v ( Anfangsknoten Eingabe: 10 Kürzeste Wege Ausgabe: Länge Kostenfunktion/Kantengewicht mit µ Oft wollen wir auch „geeignete“ Sanders: Algorithmen I 302 3.0 km

April 17, 2009 ... Kommunikationsnetze Flüsse in Netzwerken Strassennetze Spiele – – – – – ... Tippfehlerkorrektur Disk Scheduling Unterprogramm Routenplanung ! ! ! ! ! Anwendungen Sanders: Algorithmen I 303 ... v q (2) Pfad? C geben! p s April 17, 2009 kürzesten v einen q C negative Kreise immer uu es p s weitere Grundlagen just in time Gibt Es kann 10.1 Grundlagen Sanders: Algorithmen I 304

April 17, 2009 später 10.2 Azyklische Graphen Sanders: Algorithmen I 305 cross forward backward tree 3 0 g ≥ 2 f e

April 17, 2009 1 d c b 0 s Breitensuche (BFS)! Alle Gewichte gleich: 10.3 Kantengewichte Sanders: Algorithmen I 17 306 18 20 0 5 11 13 15 17 19 Distance to M W O J S Q R P V L K N M E C F G H

April 17, 2009 Fäden Knoten! → → Lösung ohne Rechner: Kanten Dijkstra’s Algorithmus Allgemeine nichtnegative Gewichte Knoten Am Startknoten anheben. Sanders: Algorithmen I 17 307 18 20 0 5 11 13 15 17 19 Distance to M W O J S Q R P V L K N M E C F G H v

April 17, 2009 . ] v [ d kürzerer Pfad: Pfad mit Hängetiefe: dann wäre einer seiner Fäden verfolge straffe Fäden ¬∃ ∃ zerrissen Korrekte Bindfäden Betrachte beliebigen Knoten Mit Hängetiefe Sanders: Algorithmen I 308 Harmful Considered Statement 1972 ACM Turingpreis THE: das erste Mulitasking-OS Semaphor Selbst-stabilisierende Systeme GOTO

April 17, 2009 Edsger Wybe Dijkstra Sanders: Algorithmen I ] v [

309

parent aetparent parent s v Kante Kante Kante v v nach nach s s ] v [ d v ) v (

µ ⊥ ≥ s

April 17, 2009 ] = v = [ ] v dieser Pfad bezeugt d [ Vorgänger von = ] aktuelle (vorläufige) Distanz von v parent [ parent[s] , = , ∞ ] 0 v [ = = Invariante: Invariante: auf dem (vorläufigen) kürzesten Pfad von parent d ] ] s v [ [ ! ! d d Initialisierung: Wie bei BFS benutzen wir zwei Knotenarrays: Allgemeine Definitionen Sanders: Algorithmen I $ u 310 parent s v u ] ] ) ) $ u v v u [ , , [ $ d u d u u ( ( c c = : ] ]+ ]+ v $ u [ [ u [ d d parent und ) v ] , v u [ ( d c April 17, 2009 < ]+ ) relaxieren ∞ u v [ , ) d u v ( ]= , c = v : [ u ] ( d v ]+ [ u [ d Kann sich mehrmals ändern! d ] v [ Beobachtung: d setze Invarianten bleiben erhalten! falls vielleicht Kante Sanders: Algorithmen I 311 ] v [ d ∞ < ] u die optimalen Entfernungen [ d d u with minimal with v u out of ) node v node ,

April 17, 2009 u ( now Am Ende deﬁniert non-scanned die zugehörigen Wege , parent non-scanned all edges non-scanned scanned d = ∃ is : u relax u parent all nodes are while und initialize Dijkstra’s Algorithmus: Pseudocode Behauptung: Sanders: Algorithmen I 312 c f f c c 7 7 7 8 8 8 7 7 7 2 2 2 9 9 9 b e b e 5 5 b e 5 1 1 1 3 3 3 0 0 0 5 5 5 d 2 a 2 a df a d 2 66 66 66 10 10 10 4 4 4 2 2 2 s s s 0 0 0 c 7 c c 8 8 8 7 7 7 2 2 2 9 9 9 5 5 b b b 1 1 1 3 3 3 0 0 0 5 5 5 2 2 d e f d e f d e f 2 a a a 10 6 10 10 10 10 10 4 4 4 2 2 April 17, 2009 2 s s s 0 0 0 Beispiel Sanders: Algorithmen I 313 ] v [ Annahme: alle Kosten nicht negativ! d irgendwann gescannt )= v wird ( : v April 17, 2009 µ V ⇒ ∈ ⇒ = v = ∀ gescannt erreichbar v v ! ! Wir zeigen: Korrektheit Sanders: Algorithmen I 314 ' ? v ) = '( k & v ungescannet −→···−→ werden nie gescannt Pfad i gescannt v v ∞ &'() – s nicht ungescannt ]= x )& −→ irgendwann gescannt [ 1 d ) − i v mit x wird ein kürzester wird relaxiert v i v April 17, 2009 ⇒ = −→ '( −→···−→ 1 1 − ∞ i ist erreichbar aber wird v gescannt v v < wird gescannt ] i 1 −→ v − [ i 1 Kante d v v erreichbar = ⇒ ⇒ ⇒ ( Annahme: s v Widerspruch – nur Knoten = = & = Sanders: Algorithmen I 315 ' v ) = '( k & v ungescannt −→··· −→ werden nie gescannt i Pfad gescannt v v ∞ &'() – s nicht ungescannt ]= x −→ )& irgendwann gescannt [ 1 ) d − i v mit x wird wird relaxiert ein kürzester v i ? v April 17, 2009 1 ⇒ = = i −→ '( −→··· −→ 1 1 − ∞ v i ist erreichbar aber wird gescannt v v < wird gescannt ] i 1 −→ wird bei Initialisierung gescannt. v − [ i 1 s Kante d v v = erreichbar = ⇒ ⇒ ⇒ 1 s & ( v Annahme: Kann auch nicht sein. Oops: Spezialfall v Widerspruch – nur Knoten = = = Sanders: Algorithmen I 316 t ' ≥ v ) = '( k & v ] Scan-Zeit v [ . ] d v [ < d ) v < ( )

t µ v ( ≥ ≤ −→···−→ µ ) Pfad i i v v v ( – &'() ]

s µ v [ ] d )& Scan-Zeit v −→ )= [ i < 1 ) v d ) , − i v 1 v ( Widerspruch! − i µ )= v unmöglich. ( ein kürzester v c ( 1 t

April 17, 2009 µ gescannte Knoten mit = ]+ < v i 1 ] gescannt. − 1 : ⇒ i t v − erste v '( −→···−→ i = [ v 1 d [ gescannt und v wurde relaxiert d v ≤ i Scan-Zeit ] v ist der i wird vor v )= −→ v [ 1 i → 1 d v Scan-Zeit von − v 1 i v − gescannt = i ⇒ ( = ⇒ : v = Wieder: Spezialfall = ( Annahme: & s v Also gilt zur Zeit &'() OBdA: µ t Sanders: Algorithmen I 317 ] v [ d ∞ < ] u [ d u with minimal with v u u out of ) v , ﬁnde

April 17, 2009 u ( non-scanned node , parent non-scanned node d = : ∃ is scanned now u u relax all edges all nodes are non-scanned while initialize Wichtigste Operation: Implementierung? Sanders: Algorithmen I 318 oder gleich items in . Q

April 17, 2009 . ] v [ ungescannte erreichte Knoten d ist Schlüssel addressierbarer Prioritätsliste Wir speichern Prioritätsliste Knoten speichern handles. Sanders: Algorithmen I 319 ) parent , d ( returns // self-loop signals root NodeArray // } × unscanned reached nodes ∞ NodeId { tentative distance from root // ∪ of // R of NodeArray ): BFS mit PQ statt FIFO NodeArray ) : s ≈ ( NodeId NodeArray

April 17, 2009 ⊥6 : : s ( 6 .insert ∞ s Q ,..., := 5⊥ ] 0; s Dijkstra ,..., = [ := ∞ NodePQ 5 ] : s = [ parent d Q d parent Initialisierung: Function Implementierung Sanders: Algorithmen I 320 u relax // uv s scanned reached update tree ) s ( // ) .insert v ( Q NodeArray 0; × := do ] s [ E d ) then decreaseKey . ; ∈ e ] s ( ) v ) Q NodeArray [ c v v ( d , := u ] ): u s ]+ [ < := u then [ ) ] =( insert e d v . Q ( [ e c Q NodeId ) := ∈

April 17, 2009 ] : ; parent v v 6 s [ ]+ do ( edge u if else d parent ∞ [ /0 deleteMin u parent . d , 8= Q d if ( ,..., Q Dijkstra := scan ∞ 5 foreach u // = return while d Function Sanders: Algorithmen I 6 ) 10 , d 6 6 6 6 6 6 ( ) ) ) ) ) ) 6 , ) ) 10 10 7 10 10 10 10 7 , , , , , , , , c 321 d d d d d d c 6 6 ( ( ( ( ( ( ( ( ) ) , 6 , , , , 6 6 , , 6 , 6 ) ) ) ) ) ) ) ) ) ) ) ) ) 6 10 10 2 2 5 7 7 7 7 7 7 7 6 0 , , , , , , , , , , , , , , , e c c d c c s a a b c c c d d ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( 5 5 5 5 5 5 Queue 5 5 5 5 5 5 5 56 56 5 5 ) ) ) ) ) ) 6 2 5 7 6 0 , , , , , , e d c s a b ( ( ( ( ( ( s b e b c b c d a d " " " " " " 4 5 1 3 2 9 8 0 2 ) → → 10 → → → → → → → → s ( b e e e s a b d s d relax relax relax relax deleteMin relax deleteMin deleteMin deleteMin deleteMin Operation insert deleteMin relax relax relax relax relax c 7 7 7 f c c f 8 8 8 7 7 7 2 2 2 9 9 9 e b e 5 b e 5 b 5 1 1 1 3 3 3 0 0 0 5 5 5 d 2 d a df a 2 a 2 66 66 66 10 10 10 4 4 4 2 2 2 s s s 0 0 0

April 17, 2009 7 c c c 8 8 8 7 7 7 2 2 2 9 9 9 b b 5 5 b 1 1 1 3 3 3 0 0 0 5 5 5 d e f d e f 2 a d e f 2 a 2 a 10 6 10 10 10 10 10 4 4 4 2 2 2 s s s 0 0 0 Beispiel Sanders: Algorithmen I 322 ) ) ) n n n ( ( ( O O O // // NodeArray } × ∞ NodeId { ∪ of R unscanned reached nodes, of // NodeArray ): NodeArray ) : s ( NodeId NodeArray

April 17, 2009 ⊥6 : : s ( 6 .insert ∞ s Q ,..., := 5⊥ ] 0; s Dijkstra ,..., = [ := ∞ NodePQ 5 ] : s [ = Q d parent d parent Function Initialisierung: Laufzeit Sanders: Algorithmen I 323 ) × × × × × × × n ( n n m m m m m O ≤ ≤ ≤ ≤ ≤ ≤ ≤ // // // // // // // // ) s ( ) .insert v Q ( NodeArray 0; × := ] do s [ E d ) then decreaseKey ; . ∈ e ] s ( ) v ) Q NodeArray [ c v v := ( d , ] u ): s u [ ]+ < := u then [ ) ] =( insert e d v . Q ( [ e c Q NodeId ) := ∈

April 17, 2009 ] ; parent : v v } s [ ]+ do ( edge u ∞ else d parent if [ /0 deleteMin parent . d , 8= Q d if ( ,..., Q Dijkstra := ∞ { u foreach = while return d Function Sanders: Algorithmen I 324 ) × × × × × × × n ( n n m m m m m O ))) ≤ ≤ ≤ ≤ ≤ ≤ ≤ n ( // // // // // // // // ) insert s T ( )+ n ) .insert ( v Q ( NodeArray 0; × deleteMin T := ( ] do · s [ n E d ) then decreaseKey ; . ∈ e ] s )+ ( ) v ) Q NodeArray [ c n v v := ( ( d , ] u ): s u [ ]+ < := u then [ ) ] =( insert e d v . Q ( [ e c Q NodeId ) := ∈ decreaseKey

April 17, 2009 ] ; parent : v T v } s [ ]+ · do ( edge u ∞ else d parent if [ /0 m deleteMin parent . d ( , 8= Q d O if ( ,..., Q Dijkstra = := ∞ { u foreach = while return d Dijkstra T Insgesamt Function Sanders: Algorithmen I ))) n 325 ( ) ) v v , , insert u u T ( ( c c )+ n ]+ ]+ ( u u [ [ d d := := ] ] deleteMin v v [ [ T ( d d komplett durchsuchen · d n )) )+ 1 n ( + n ( · n " 2 + n decreaseKey 1 T + · · m m m ! ( ( O O O )

April 17, 2009 1 ( ) = = = O n ( ) O 1 ( O Dijkstra Dijkstra59 T T deleteMin insert decreaseKey ! ! ! Dijkstra’s ursprüngliche Implementierung: „naiv“ Laufzeit Sanders: Algorithmen I ))) n ( 326 insert T )+ n ( : deleteMin T )) ( 1 · + n n )+ n log ( ( ) · n n + log n ) n decreaseKey T log + · · Binary-Heapprioritätslisten m m m (( ( ( ) O O O n )

April 17, 2009 n = = = log ( ) O log n ( O log ( Dijkstra T O DijkstraBHeap T deleteMin insert decreaseKey ! ! ! Bessere Implementierung mit Laufzeit Sanders: Algorithmen I ))) n ( 327 insert T )+ n ( deleteMin T ( · : )) n 1 + )+ n n ( ) log ( n · sind hier größer! n log ) · + n decreaseKey ( T 1 + · · O m m m ( ( ( (amortisiert) (amortisiert) O O O ) )

April 17, 2009 n 1 ( = = = Fibonacci-Heapprioritätslisten O log ( ) O 1 ( O Dijkstra T DijkstraFib T deleteMin insert decreaseKey ! ! ! Aber: konstante Faktoren in (Noch) besser mit Laufzeit Sanders: Algorithmen I 328 . n m log n log n + m - O ]=

April 17, 2009 DijkstraBHeap T [ E In Algorithmen II Beweis: Dann gilt Modell: Kantengewichte sind „zufällig“ auf die Kanten verteilt 10.4 Analyse im Mittel Sanders: Algorithmen I 329 . schnellere Algorithmen ) n " + m (

April 17, 2009 O in Algorithmen II u.U. bis herunter zu Das kann man ausnutzen. Beobachtung: In Dijkstra’s Algorithmus steigt das MinimumPrioritätsliste in monoton. der 10.5 Monotone ganzzahlige Prioritätslisten Details: Sanders: Algorithmen I 330 3 3 g h 2 − − − 2 5 − 1 f i 2 − ... 2 1 v − ∞ 0 q ∞ s d 0 − − 1 (2) ]= − 0 v C [ d ∞ j ∞ − 0 p − s 2 April 17, 2009 42 − v ∞ ∞ k ab vermeiden! + − q C uu p s Endlosschleifen Wie ﬁnden wir heraus, welche das sind? Was machen wir wenn es Kanten mit negativenEs Kosten gibt? kann Knoten geben mit 10.6 Negative Kosten Sanders: Algorithmen I 3 3 ... g h 2 − − v 331 − 2 5 − q 1 f i 2 − (2) 2 1 C − (eng. simple) 0 p ∞ s d 0 − s 1 − 0 v einfach -Pfad. ∞ j ∞ v q – − 0 − s 2 42 C : − ist OBdA ∞ (Abschnitt 10.1 im Buch) P ∞ uu k ab + − ⇒ p = s P -Pfad einfacher, nicht längerer Pfad. v –

April 17, 2009 s " -Pfad v – s kürzesten ∃ betrachte beliebigen nicht-einfachen über negativen Kreis erreichbar? v kürzesten Beweisidee: Fall: Alle Kreise streichen Sonst: ¬∃ Zurück zu Basiskonzepten Lemma: viele immer kürzere) (sondern beliebig Sanders: Algorithmen I 332 d − c − b , c − b c f 7 − a 8 7 2 , d 9 − e 5 b c 1 , c 3 0 5 − b d 2 a , 66 10 b − 4 2 aus zusammen bilden einen Baum falls es a s s 0 "

April 17, 2009 d − c − b − Kürzeste-Wege-Baum a Übung: Alle kürzeste Pfade von keine negativen Kreise gibt. Übung, Zeige: Teilpfade kürzester Pfade sind selbst kürzeste Pfade Mehr Basiskonzepte Sanders: Algorithmen I 333 ) ···6 ) k 1 2 k k e t t t t ) '( ( k ein kürzester Weg. 6 k relax & v ) k ··· v ) ) ( 2 ,..., µ e 2 ( 2 v t '( , nach Zeitpunkt nach Zeitpunkt nach Zeitpunkt 1 ]= bei Initialisierung ) ) ) k v k 1 2 ) & relax , v s v v v [ s ( ( ( ( 5 d ··· µ µ µ µ

April 17, 2009 ) ) = 1 6 ··· e k ]= ]= ]= ]= ( 1 k s e 1 2 t (Eigentlich Induktion über '( [ v v v [ [ [ d d d d relax & ,..., 2 e 5··· , 1 = e 5 R = p Beweisskizze: Sei Allgemeines Korrektheitskriterium eine Folge von Relaxierungsoperationen und Dann gilt anschließend Sanders: Algorithmen I 334 k v=v mal 1 − (k−1). Runde n Kanten 1 − n 3. Runde haben höchstens 3 G

April 17, 2009 v 2. Runde 2 v kürzeste Pfad ist eine Teilfolge dieser Relaxierungen! 1 1. Runde Jeder für beliebige Kantengewichte Wir relaxieren alle Kanten (in irgendeiner Reihenfolge) Algorithmen Brutal – Bellman-Ford-Algorithmus Alle kürzeste Pfade in s=v Sanders: Algorithmen I 335 ∞ − )= x (

µ haben x Knoten ] v [ d

April 17, 2009 < ) : erreichbaren e ( C v c ∈ ) ]+ Übung v u , [ u d ( ∃ negativen Kreise C: ∀ und alle von Nach Ausführung von Bellman-Ford: Negative Kreise Finden Beweis: v Sanders: Algorithmen I 336 3 3 3 ∞ h 2 2 − − − + 2 2 − − 5 5 − − 1 1 i 2 2 − − 2 2 1 1 Beispiel − − 0 0 ∞ s 0 0 ... − 1 1 − − 0 0 ∞ ∞ j 0 00 − 0 0 − 2 2 42 42 − − ∞ ∞ ∞ k + + 42 − 3 ∞ ∞ ∞ ∞ ∞ 2 2 2 − + + + + + 2 2 2 − − − 5 5 5 − − − 1 1 ∞ ∞ ∞ ∞ − + + − + + 2 2 2 1 1 1 April 17, 2009 − − − 0 0 0 ∞ 0 0 0 0 + 1 1 1 − − − 0 0 0 ∞ ∞ ∞ ∞ ∞ 00 + + + + + 0 0 0 2 2 2 42 42 42 − − − ∞ ∞ ∞ ∞ ∞ ∞ + + + + + +

Sanders: Algorithmen I 337 . best case

April 17, 2009 viel langsamer als Dijkstra ! ) nm ( O Bellman-Ford – Laufzeit Es gibt Algorithmenvarianten mit viel besserem Sanders: Algorithmen I 338 9 ! 8 7 6 5 4 2 3 1 ) v ( s scan topologischen Sortierung : 6 n do v keine negativen Kreise ! ,..., 1 ⇒ v 5 =

April 17, 2009 topological order ) n in + V m ∈ ( , parent v d O initialize foreach Laufzeit: Beobachtungen: Keine (gerichteten) Kreise Azyklische Graphen (10.2 im Buch) Für jeden (kürzesten) Pfad Die Knoten sind aufsteigend bzgl. jeder Sanders: Algorithmen I 339 . )) n log n + m ( . n " ( m . O 2 )) n n ! Zeit O log n Zeit + m ( Dijkstra) n ( × O n April 17, 2009 nach Überall s + von × n Bellman-Ford) Dijkstra) Bellman-Ford × × × 1 n n ( ( In Algorithmen II: Zeit ( beliebige Kantengewichte: Im Prinzip: 10.7 Von Überall nach Überall nichtnegative Kantengewichte: Sanders: Algorithmen I 340 t bestimmten s t zu einem s entfernt wird Q aus ? t

April 17, 2009 wissen wollen t Frage: Wieviel spart es (meist) beim Europa-Navi? Dijkstra hört auf, wenn Was machen wir, wenn wir nur die Distanz von 10.8 Distanz zu einem Zielknoten Trick 0: Knoten Spart “im Durchschnitt” Hälfte der Scans Sanders: Algorithmen I 341 t z t t s s s s suche

April 17, 2009 tabellieren Suche Rückwärts ausnutzen + Teilabschnitte Hierarchien Zielgerichtete Vorwärts ! ! ! ! mehr in Algorithmen II, Algorithm Engineering Ideen für Routenplanung Sanders: Algorithmen I 342

April 17, 2009 Transit-Node Routing Sanders: Algorithmen I 343 isen Kantengewichte nichtnegative

April 17, 2009 Graphen azyklische und Prioritätslisten sind wichtige Datenstruktur Optimale Lösungen bei nicht (ganz) trivialen Korrektheitsbewe Einfache, efﬁziente Algorithmen für ! ! ! Kürzeste Wege: Zusammenfassung Sanders: Algorithmen I 344 ) n siehe auch loglog n + m ( O " abwägen

April 17, 2009 in beliegiger Reihenfolge anfahren disjunkte Wege Zielfunktionen Ziele Optimierungskapitel Mehrere Mehre Mehre ! ! ! Fast alles schwierig (NP-hart) Verallgemeinerungen [Thorup 2004] Viele Arbeiten zu besseren Prioritätslisten Mehr zu kürzesten Wege Sanders: Algorithmen I 345 d 2 b 4 7 9 3 c

April 17, 2009 6 a 11 Minimale Spannbäume Sanders: Algorithmen I 346 7 2 3 5 2 1 4 9 . ) der alle Knoten E ) , e ( V . c V T =( ∈ e G ∑ } n Gewicht ,..., 1 { . = + V R , two-element subsets of minimalem | ∈ April 17, 2009 E | ) mit , e.g., e ) | ( = c T V | , m , V = ( E n , ∈ e V Finde Baum Knoten Kanten Kantengewichte ungerichteter (zusammenhängender) Graph Minimale Spannbäume (MSTs) verbindet. Sanders: Algorithmen I 347 aufspannt. G der alle T

April 17, 2009 nicht zusammenhängend, ﬁnde G minimalen spannenden Wald Falls Minimale spannende Wälder (MSF) verallgemeinern. MST Algorithmen lassen sich leicht zu MSF Algorithmen Zusammenhangskomponenten von Sanders: Algorithmen I 348 7 2 3 5 2 1 4 9 . Steinerbaumproblem , : Bildsegmentierung für schwere Probleme, z. B.

April 17, 2009 -Pfad, : Lass schwere MST-Kanten weg. Teilbäume deﬁnieren t – s Siehe Buch, VL G. theoretischer Informatik, Algorithmen II. Handlungsreisendenproblem dessen max. Kantengewicht minimal ist. Dies ist der Pfad im MST! Suche Cluster. Konkret z. B. Näherungslösungen Clustering Bottleneck-Shortest-Paths Netzwerk-Entwurf ! ! ! ! Anwendungen Sanders: Algorithmen I 7 2 3 349 5 2 9 1 4 } S \ betrachte die Schnittkanten V V ∈ v ⊂ , S S C ∈ April 17, 2009 u : E Kante in ∈ } v , u {{ leichteste = kann in einem MST verwendet werden. Die Für beliebige Teilmenge Die Schnitteigenschaft (Cut Property) 11.1 MST-Kanten auswählen und verwerfen C Sanders: Algorithmen I 7 2 3 350 5 2 9 1 4 V\S V\S e e’ e’ e S S zwischen $ e } S \ betrachte die Schnittkanten V auch ein MST. . V } ∈ ) $ .) e v ⊂ ) e { $ , ( S e S c ∪ C ( benutzt Kante c } $ ∈

April 17, 2009 $ ≤ e T u ) { : e )= ( \ e c $ E ( Kante in c T ∈ mit } = S v , T \ u V {{ leichteste = und kann in einem MST verwendet werden. Die Angenommen MST Beweis: Dann ist Für beliebige Teilmenge Die Schnitteigenschaft (Cut Property) S (Es gilt sogar, C Sanders: Algorithmen I 351 7 2 3 5 2 1 4 9

April 17, 2009 Kante auf einem Kreis wird nicht für einen MST benötigt schwerste Die Die Kreiseigenschaft (Cycle Property) Sanders: Algorithmen I 7 2 3 352 5 2 1 4 9 $ e auch ein MST. . ) } .) $ e ) e $ { ( e benutzt die schwerste Kante c ( ∪ $ c } ≤ T $

April 17, 2009 e ) e { )= ( e \ c ( $ c Kante auf einem Kreis wird nicht für einen MST benötigt T mit = C T schwerste Die Beweis. Angenommen MST Die Kreiseigenschaft (Cycle Property) Dann ist auf Kreis (Es gilt sogar, Sanders: Algorithmen I 353 2 2 2 b b b d d d 7 7 7 4 4 4 9 3 9 9 3 3 c c c a a a 6 6 6 S s cut property for

April 17, 2009 } ) v , u } ( fulﬁlling the times v { ) { 1 v ∪ , ∪ − u T for arbitrary start node [Jarník 1930, Prim 1957] S ( n } := s := { S T ﬁnd := /0 := repeat T S Idee: Lasse einen Baum wachsen 11.2 Der Jarník-Prim Algorithmus Sanders: Algorithmen I 354 v e u u relax // S S T T ) update tree s ( // ) .insert v Q ( 0; := ] }} do s s [ { E weitgehend analog zu Dijkstra d \ ; .decreaseKey ∈ // s V ) ) Q v v := ∈ ( , ] u s u v [ ) then : := e ] then Edge ( ] v =( ]) [ c v .insert Q [ v e d [ of Q := ∈

April 17, 2009 ] ; parent < v v } [ ) do edge e ∞ parent if else d V parent ( /0 u , .deleteMin c v ∈ ( 8= Q if s { ,..., Q jpMST : Set := scan ∞ { // foreach u = return while pick any d Function Sanders: Algorithmen I 355 Warum? nicht PQs reichen ) ) n binären Heaps log monotone n Fibonacci Heaps ( mit

April 17, 2009 O ) mit n ) n log Zeit ausserhalb der PQ ) log ) n n n decreaseKey + + + ) m m m m deleteMin (Zeit (( ( ( ( O O O O n ! ! ! " " Wichtigster Unterschied: Praktisch identisch zu Dijkstra Analyse Sanders: Algorithmen I 356 2 b 7 4 9 3 cd a 6 do then Join two subtrees ) 2 // b T , subforest of the MST V ( // 7 4 9 3 [1956] c 6 2 b dd } 7 4 ) 9 3 v , different subtrees of

April 17, 2009 u in ascending order of weight ( c aa { 6 E ∪ ∈ are in T ) v 2 v b , := d u ( T and T u 7 4 9 3 if := /0 c a 6 return T foreach 11.3 Kruskals Algorithmus Sanders: Algorithmen I )) u ( 357 6 Komponente \ T V , ) do u then Join two subtrees ( ) -Pfad in // T u , subforest of the MST – V v benutze Kreiseigenschaft ( , benutze Schnitteigenschaft // v : , u 5 Komponente ( Kreis } ) Kante im Kante im cut v , different subtrees of

April 17, 2009 u in ascending order of weight ( { E ∪ ∈ are in T schwerste leichteste ) MST MST v v , := ist ist 8∈ ∈ u ) ) ) ) in verschiedenen Teilbäumen ( T and v v v v T v , , , , u , u u u u u ( ( ( ( if := /0 ⇒ ⇒ ⇒ ⇒ = = = = return foreach T Kruskals Algorithmus – Korrektheit Sonst: Fall Sanders: Algorithmen I 2 M 358 k M union ... j k ... M ... ij i 1 M ,. . . , 1 . i M , /0 n .. = to a single block. 1 j j = M k ∩ and i M i , d. h., Mengen (Blocks) ) n M n n .. : .. .. j 1 :1 ∪···∪ ) : 1 8= j n 1 i , .. ∀ i M ) ( :1 N April 17, 2009 i : ( n der Menge union a unique identiﬁer for the block containing ( ﬁnd Partition join the blocks containing return UnionFind Procedure Function Class Verwalte 11.4 Union-Find Datenstruktur mit Sanders: Algorithmen I n 359

... . 2 1 i parent[i] n .. 1 of Partition-Reps ] n i .. 1 [ ]) i [ n .. Array ) : 1 : parent n ( then return 6 .. ) i n ﬁnd :1 N April 17, 2009 i : ( ]= i n ,..., [ ( 2 parent-refs lead to unique ﬁnd , 1 5 parent = if else return UnionFind invariant Function parent Class Union-Find Datenstruktur – Erste Version Sanders: Algorithmen I j n 360

... . 2 i 1 i parent[i] j )) j ( i n .. find , 1 ) i ( of Partition-Reps ] n find i .. ( 1 [ ]) link i ) [ n n .. ) .. n then Array .. :1 ) : 1 ) : parent j j n ( :1 ( then return , 6 are representatives of different blocks .. j i ) i n j ( , find i j :1 N April 17, 2009 find ( i : ( ]= i 8= := n and ,..., [ union link ( ] ) i 2 i i parent-refs lead to unique find , [ ( 1 5 find parent = assert if if else return parent UnionFind Procedure Procedure invariant Function parent Class Union-Find Datenstruktur – Erste Version Sanders: Algorithmen I 361 . i parent[i] im schlechtesten Fall ! ) n (

April 17, 2009 Θ braucht konstante Zeit braucht Zeit find-Pfade kurz halten union find : : + − zu langsam. Idee: Analyse: Union-Find Datenstruktur – Erste Version Sanders: Algorithmen I n . . . 362 ... ] i [ 2 i i’ 1 parent . . . // n .. 1 of ] n i .. 1 [ n ) .. ] i Array ) : 1 $ : i n then return 6 .. parent[ ) i := n $ ( i ] :1 N April 17, 2009 i [ i : ( ]= find i n ,..., [ ( 2 := find , $ 1 return i parent 5 parent = if else UnionFind Function parent Class Pfadkompression Sanders: Algorithmen I j j n 3 ... 2 3 363 i i 1 j j 3 2 2 2 i i n j n .. 1 ]++ := i log [ ] i of .. [ ] 0 n rank .. of 1 ] [ parent n .. then 1 ] [ j ) [ n then Array .. ] : j i rank [ :1 6 are representatives of different blocks j Array ) := n j , : ] ]= i N April 17, 2009 rank j i ( : [ 6 [ 0 < n and ,..., link ] ( i 2 i rank [ , 1 parent if ,..., 5 0 rank 5 = else assert if = UnionFind Procedure rank parent Class Union by Rank Sanders: Algorithmen I 364 ] x [ ] gen x 2 [ ) n hat Länge höchstens gen x log ( O ’s Menge hat Größe mindestens x ⇒

April 17, 2009 ist Repr. ﬁnd braucht Zeit Der Pfad zum Repr. x invariant invariant Korollar: Analyse – nur Union-by-rank Sanders: Algorithmen I 365 (amortisiert) ) n log ( O

April 17, 2009 im Buch ﬁnd braucht Zeit Beweis: Satz: Analyse – nur Pfadkompression Sanders: Algorithmen I , , . 366 1 2 2 ≥ ≥ ≥ . i j j . for m for , and n 2 mit ≥ i )) n for , m , ( } T n α m Union-by-rank ( log O inverse Ackermannfunktion ≥ + ) * die physikalisch denkbaren n T /

α m )) ) 1 , i für alle und ( − 5 j A , i ≤ ( ) 1: link brauchen Zeit 2 A

April 17, 2009 , , ≥ × 1 1 aber i n { ) − − 1 i i + ( j ( ( A min 2 A ω ﬁnd [Tarjan 1975, Seidel Sharir 2005] Ackermannfunktion )= )= )= )= )= × j j n 1 n m , , , , , i i 1 ( ( m m ( ( ( A A A ist die T T Beweis: und Satz: A Analyse – Pfadkompression α α Sanders: Algorithmen I 367 T sort // reicht auch link do // Wurzelbäume → encodes components of forest // then ) v ( als die Bäume im MSF ) Kantenliste

April 17, 2009 v } in ascending order of weight Tc.ﬁnd , v Blöcke in Partition u , E 8= ( u ) . Schneller für ganzzahlige Gewichte. ↔ ) { ∈ n ) u ) ( m v n , .. u log ( 1 output Tc.union anderer Struktur m Tc.ﬁnd = ( UnionFind( if O V : aber mit Tc Zeit Bäume im MSF foreach Graphrepräsentation: Sei Kruskal mit Union-Find Sanders: Algorithmen I 2 368 2 2 0 7 4 6 9 0 compress 1 1234 1 34 3 2 2 2 0 7 4 6 9 link 0 1 1234 1 34 3 2 1 0 7 4 6 9 0 link 1234 1

April 17, 2009 12 34 3 2 01 7 4 link 9 0 6 1234 0 34 12 3 Beispiel Sanders: Algorithmen I 369 ,. . . ) n / ganzzahlig, parallel m Kruskal n ↔ , m n F

April 17, 2009 ) m n auch gut für große ( gut für alle O Kantenliste = m Proﬁtiert von schnellen Sortierern ( Verfeinerungen Braucht nur Gut für Asymptotisch Sehr schnell für ! ! ! ! ! ! Pro Kruskal Vergleich Jarník-Prim Pro Jarník-Prim Sanders: Algorithmen I 370 ] , 1926 eraufwand). [Boruvka [Chazelle 2000] [Karger Klein Tarjan 1995] [Pettie, Ramachandran 2000] [Sanders Schultes Sibeyn 2004] )) n Algorithmus , ) m m

April 17, 2009 ( ( T Algorithmus ) O α n externer m det. ( log O e Zeit m ( O [Osipov Sanders Singler 2009] Praktikabler Verbesserung von Kruskal (parallelisierbar, weniger Sorti parallelisierbar, externalisierbar Zutat vieler fortgeschrittener Algorithmen “optimaler” “Invented here”: Det. Zeit Erwartet Zeit ! ! ! ! ! Mehr MST-Algorithmen Sanders: Algorithmen I 371 16 8 22 2 = 4 n 2

April 17, 2009 Kruskal qKruskal Kruskal8 filterKruskal+ filterKruskal filterKruskal8 qJP pJP number of edges m / number of nodes n number of edges m / number of nodes 1

100 1000 [ns] m / time Messungen, Zufallsgraph, Sanders: Algorithmen I 372 . . Prioritätsliste Analyse nichttrivialer . Datenstrukturen abstrakten Problemeigenschaften Union-by-rank Algorithmen mit und eigenschaft als Basis für abstrakte Algorithmen. April 17, 2009 Kreis einfache : effiziente Verwaltung von Partitionen mittels JP. ≈ -Algorithmus effizient implementiert mittels - und Beispiel für Pfadkompression Greedy Auch ein Entwurfsprinzip. . . Suche nach einfachen, Entwurfsprinzip: Noch ein Entwurfsprinzip: Union-Find Dijkstra Implementierung braucht effiziente Schnitt ! ! ! ! Zusammenfassung Sanders: Algorithmen I 373

April 17, 2009 Lokale Suche Evolutionäre Algorithmen Systematische Suche Greedy Dynamische Programmierung Black-Box-Löser ! ! ! ! ! ! 12 Generische Optimierungsansätze Sanders: Algorithmen I 374 5 4 3 2 1 M i p proﬁt 20 und N ∈ Rucksackproblem i w i p 15 x von Gegenständen ∈ i x und ∑ Gewicht W

April 17, 2009 ≤ i w x 20 ∈ i ∑ Gegenstände mit maximiere den Proﬁt Wähle eine Teilmenge so dass n 10 ! ! ! ! Durchgehendes Beispiel: Sanders: Algorithmen I 375 L ∈ x ) f , für alle ) L x ( ( f ≥ ) ∗ x ( f Lösung falls

April 17, 2009 Zielfunktion optimale R zulässige Lösungen : ist → U L variantenreich, meist NP-hart L ⊆ ∈ : ∗ f x L ! ! ! Minimierungsprobleme: analog Problem: Allgemein: Maximierungsproblem Sanders: Algorithmen I 376 Verallgemeinerung von beidem ≈

April 17, 2009 Constraint-Programming (Ganzzahlige) Lineare Programmierung Aussagenlogik ! ! ! 12.1 Black-Box-Löser Sanders: Algorithmen I 377 n R . ∈ i } a i , b } i wird durch = "# , x ≥ · , i a ≤ { ∧ . 0 ∈ i Constraints i a ≥ m "# i x mit : und i m b i ≤ "# i x x · ≤ · i Variablen 1 c a n ∀ : n )= mit x R April 17, 2009 ( f ∈ der Form x -te Komponente von Vektor j { = Kostenvektor die ij L a constraints ist der Sei Wir erhalten c m Kostenfunktion lineares Programm ! ! das folgende Minimierungs/Maximierungsproblem deﬁniert Ein Lineare Programmierung Sanders: Algorithmen I 378 26 ≤ y 4 8 + ≤ x x y − x Lösungen bessere 2 8 6 ≤ y ≤ y + zulässige Lösungen x (2,6)

April 17, 2009 y Ein einfaches Beispiel Sanders: Algorithmen I 379 E ∈ ) w , v ( für alle ) w , v ( c + v 0 d v ≤ = d s w V d ∈ d ∑ v

April 17, 2009 so dass maximiere Beispiel: Kürzeste Wege Sanders: Algorithmen I 380 i j Prozent des täglichen Bedarfs

April 17, 2009 Euro/kg. ji i a c als i x kostet enthält i i Anforderungen an gesunde Ernährung. Futtersorten. zu beschaffende Menge von Sorte pro kg bzgl. Anforderung Sorte Sorte (Kalorien, Proteine, Vitamin C,. . . ) LP-Lösung gibt eine kostenoptimale “gesunde” Mischung. Deﬁniere m n ! ! ! ! Eine Anwendung – Tierfutter Sanders: Algorithmen I 381

April 17, 2009 Abstand wachsende Transportkosten) Garbage in Garbage out die meisten nichtlinearen Kostenfunktionen Ganzzahlige Mengen (für wenige Tiere) Minimale Abnahmemengen bestimmte abschnittweise lineare Kostenfunktionen (z. B. mit Obere Schranken (Radioaktivität, Cadmium, Kuhhirn, . . . ) Beschränkte Reserven (z. B. eigenes Heu) ! ! ! ! ! ! ! Grenzen Verfeinerungen Sanders: Algorithmen I 382 [Khachiyan 1979] . 7 2 ) n , m ( polynomieller Zeit lösen

April 17, 2009 max - O Fertige freie und kommerzielle Pakete Robuste, efﬁziente Implementierungen sind sehr aufwändig In der Praxis geht das viel schneller LPs lassen sich in Worst case ! ! ! ! " Algorithmen und Implementierungen Sanders: Algorithmen I 383 n } 1 , 0 { . ∈ April 17, 2009 i N Entferne die Ganzzahligkeitsbedingungen eines x ∈ i x Variablen ganzzahlig sein müssen. Mixed Integer Linear Program, lineares Programm bei dem oft: 0/1 ILP mit (M)ILP einige Bedingung Integer Linear Program, lineares Programm mit der zusätzliche Ganzzahlige Lineare Programmierung Sanders: Algorithmen I Lineare Relaxation: MILP: ILP: 384 5 4 3 2 1 M . n ≤ i ≤ 20 1 x · for p } 1 , 0 { ∈ 15 i maximiere x , in den Rucksack kommt. i M

April 17, 2009 ≤ x · 20 w gdw Gegenstand 1 10 = i 0/1 Variablen sind typisch für ILPs x so dass Beispiel: Rucksackproblem Sanders: Algorithmen I 385 . runden g. fraktionale Variable in Kapazität G eine gibt es nur

April 17, 2009 Rucksackproblem : Beim Die Lösung der linearen Relaxierung hilft oft, z. B. einfach Ausgefeilte Softwarepakete funktionieren Viele Möglichkeiten für Näherungslösungen Es gibt generische Lösungsansätze, die manchmal gut Ausdrucksstarke Modellierungssprache NP-hard + + + + − + der linearen Relaxierung – abrunden ergibt zulässigeAnnähernd Lösun optimal falls Gewichte und Proﬁte Beispiel Umgang mit (M)ILPs Sanders: Algorithmen I 386 -Algorithmen Greedy Algorithmen, wenig gebräuchlich) optimale Entscheidung lokal

April 17, 2009 gierige (deutsch: 12.2 Nie Zurückschauen – Idee: treffe jeweils eine Sanders: Algorithmen I 387 kürzeste Wege

April 17, 2009 Kruskal Jarník-Prim – – Selection-Sort (wenn man so will) Dijkstra’s Algorithmus für Minimale Spannbäume ! ! ! Mehr: Vorlesungen Algorithmen II und Approximations- und Onlinealgorithmen Viel häuﬁger, z.T. mit Qualitätsgarantien. Näherungslösungen mit Greedy-Algorithmen Optimale Greedy-Algorithmen Sanders: Algorithmen I

388

1 M roundDown optimal 3

33 greedy = M 1 greedy M critical item roundDown, // 3 w w 22 4 2 1 2 1 1 p 1 Instance Solutions: p 4 2 1 M then i i i i i p p w w M > 1 9 1 −

April 17, 2009 = j i j do ∑ .. n profit density profit density : 1 j to 8 insert it into the knapsack greedyKnapsack roundDownKnapsack there is room for item := 1 if max i output items for find sort items by sort items by Procedure Procedure Beispiel: Rucksackproblem Sanders: Algorithmen I 389 gilt: es is egal welches benutzt wird. ⇒ Optimalitätsprinzip

April 17, 2009 . aus Bausteinen Teilprobleme Mehrere optimale Lösungen Optimale Lösungen bestehen aus optimalen Löungen für ! ! Anwendbar wenn, das 12.3 Dynamische Programmierung – Aufbau Sanders: Algorithmen I 390 ) i p )+ i w unter Benutzung , i − ) C C , , ,. . . , 1 1 1 − − i i ( ( P P ( max Gegenstände )= C , i ( P e Gewichte April 17, 2009 Proﬁt für : . n C ≤ ≤ i ≤ optimaler ganzzahlig 1 ∀ := ) C Kapatzität , i ( P Annahme: Beispiel: Rucksackproblem Lemma: von Sanders: Algorithmen I 391 ) . i p C )+ i w bei Kap. − i C , ... 1 ,. . . , 1 1 − i = ( i x P , ) , benutze optimale Teillösung. C , 0 Setze 1 = : i − i Gegenstände i p x ( P ( )+ i w Setze

April 17, 2009 max : Profit für − ) C C , , )= 1 1 C , − − i i i ( ( ( optimaler P P P := ≥ ≥ ) ) ) C , C C i , , ( i i ( ( P Beweisanfang: Lemma: Sanders: Algorithmen I P P 392 ) . i p C ∧ )+ x x i · · w p p bei Kap. − ) i i < < C p , 1 ,. . . , 1 )+ − i i w ( P − , ) i C , C p −→ , 1 1 − )+ − i i Gegenstände nicht i ( w ( P P , − ) ( ) C C C für das Teilprolem so dass , , , 1 1 1 April 17, 2009 max Profit für − − − i i i ( ( ( )= optimal P P P C ( , i ( optimaler ist is P max x : := ≤ ) x ) C angenommen das stimmt ∃ , C i , ( i ( P Beweis fortgesetzt: Lemma: Sanders: Algorithmen I P 393 für $ ) . x i p C ∧ )+ x x i · · w . Außerdem, p p i bei Kap. − . Außerdem gilt, p ) i i ) < < C p C − , , 1 x ,. . . , 1 · 1 )+ − i − p i i w ( ( = P − P $ , ) x . Widerspruch i C · , x C p −→ , · 1 p 1 p − )+ − i i ≥ Gegenstände nicht i ( w i ( P p P , . Widerspruch − erhalten wir eine zulässige Lösung ) ( ) x mit Profit 0 C C · C für das Teilprolem so dass , , )+ ) , i i p 1 1 1

April 17, 2009 = max Proﬁt für w w i − − ≥ − x i i − − i ) ebenfalls zulässig für ( ( ( )= optimal C C C P P x Mit P , , , C ( , : : 1 1 1 i 0 1 ( − − − optimaler ist is P i i i max = = x ( ( ( i i : := P P P x x ≤ ) x ) C angenommen das stimmt ∃ , C Fall Fall i , ( i ( P Beweis weiter fortgesetzt: Lemma: Sanders: Algorithmen I P 394 )] 0 ) ,..., C , 0 1 ( − i ( ,..., P ) 0 ]= C [ ,..., 0 i :P then p } ] C M ] = [( [ ]+ i P M do ) w ] i := 1 > 0 ,..., M ] i ... w − , 1 p 0 C n { C , , [ i , n elementweise: [ P ,..., c ∈ ]+ i 0 ) , := C ... p w C ] ∀ , April 17, 2009 1 downto i [ − C ( ] = [ [ do P M C P decision n [ M P := to ... if C knapsack( 0 [ invariant: := 1 // for i for array P bitarray decision Procedure Berechung von Sanders: Algorithmen I 395 bits. Mn i w − C := ] C C

April 17, 2009 do , i polynomiell [ 1 Maschinenwörter plus ) then n ( ] 1 pseudo n O ) downto + ]= ... i := decision [ x n 1 nM ] [ M x i ( [ x := M if x O i := return endfor for array Rekonstruktion der Lösung Analyse: C Sanders: Algorithmen I Space: Zeit: 396 ) 1 0 10, ( 5 ) 1 4 0 10, ( ) 1 3 0 10, ( ) 1 x · 2 0 10, ( ) 5 ) 20 ]) ≤ , 1

April 17, 2009 C x , 15 · i [ , ) 1 0 10, ( 4 20 , , 2 ) , 0 10 3 ( , decision 1 0 0 0, ( ( ( , ) C C , i \ ( 3 4 1 2 i 0 so dass P maximiere Beispiel Sanders: Algorithmen I 397 ) ) 1 1 0 10, ( 30, ( 5 ) ) 1 1 4 0 10, ( 30, ( ) ) 1 1 3 0 10, ( 20, ( ) ) 1 0 x · 2 0 10, ( 10, ( ) 5 ) ) 20 ]) ≤ , 1 0

April 17, 2009 C x , 15 · i [ , ) 10, ( 1 0 10, ( 4 20 , , 2 ) ) , 0 0 10 3 ( , decision 1 0, ( 0 0 0, ( ( ( , ) C C , i \ ( 3 4 1 2 i 0 so dass P maximiere Beispiel Sanders: Algorithmen I 398 ) ) ) 1 1 1 0 10, ( 30, ( 35, ( 5 ) ) ) 1 1 0 4 0 10, ( 30, ( 30, ( ) ) ) 1 1 1 3 0 10, ( 20, ( 25, ( ) ) ) 1 0 1 x · 2 0 10, ( 10, ( 15, ( ) 5 ) ) ) 20 ]) ≤ , 1 0 0

April 17, 2009 C x , 15 · i [ , ) 10, ( 10, ( 1 0 10, ( 4 20 , , 2 ) ) ) , 0 0 0 10 3 ( , decision 1 0, ( 0, ( 0 0 0, ( ( ( , ) C C , i \ ( 3 4 1 2 i 0 so dass P maximiere Beispiel Sanders: Algorithmen I 399 ) ) ) ) 1 1 1 0 0 10, ( 30, ( 35, ( 35, ( 5 ) ) ) ) 1 1 0 0 30, ( 4 0 10, ( 30, ( 30, ( ) ) ) ) 0 1 1 1 25, ( 3 0 10, ( 20, ( 25, ( ) ) ) ) 0 1 0 1 x · 15, ( 2 0 10, ( 10, ( 15, ( ) 5 ) ) ) ) 20 ]) ≤ , 0 1 0 0

April 17, 2009 C x , 15 · i [ , ) 10, ( 10, ( 10, ( 1 0 10, ( 4 20 , , 2 ) ) ) ) , 0 0 0 0 10 3 ( , decision 1 0, ( 0, ( 0, ( 0 0 0, ( ( ( , ) C C , i \ ( 3 4 1 2 i 0 so dass P maximiere Beispiel Sanders: Algorithmen I 400 einfach einfach Beweisnot Kreativität! Standard-Trickkiste ? Lösungstabelle

April 17, 2009 der Lösung Teilprobleme sind die setzen sich optimale Lösungen aus Teilproblemlösungen Rekonstruktion Wie Was Platz sparen, Cache-efﬁzient, Parallelisierung zusammen? 4. 5. Verfeinerungen: 3. Bottom-up Aufbau der 2. 1. Programmierung Algorithmenentwurf mittels dynamischer Sanders: Algorithmen I 401 Übung? Übung? Teilpfade Algorithmen II? füllen Teil des Rucksacks i .. 1 Gegenstände

April 17, 2009 Rucksackproblem Geld wechseln Verkettete Matrixmultiplikation Bellman-Ford Alg. für kürzeste Wege Edit distance/approx. string matching ! ! ! ! ! Anwendungen dynamischer Programmierung Sanders: Algorithmen I 402 Runden auf dem 20 Runden. 21

April 17, 2009 strategie für Teil ⇒ Keine gute Frage: Wie kann man constrained shortest pathdynamischen trotzdem Programmier-problem als modellieren? Angenommen, die schnellste Strategie für Hockenheimring verbraucht den Treibstoff vollständig. Gegenbeispiel: Teilproblemeigenschaft Sanders: Algorithmen I 403

April 17, 2009 Optimale Graphfärbungen sind nicht austauschbar. Gegenbeispiel: Austauschbarkeit Sanders: Algorithmen I 404

April 17, 2009 Alle (sinnvollen) Möglichkeiten ausprobieren. Puzzles konkrete NP-harte Probleme Strategiespiele Theorembeweiser (Prädikatenlogik,. . . ) Constraint Satisfaction SAT (Aussagenlogik) Integer Linear Programming (ILP) ! ! ! ! ! ! ! Idee: Anwendungen: 12.4 Systematische Suche Sanders: Algorithmen I 405 L : L ) M ): , ) M n , ) w n w are ﬁxed, ,..., 1 1 − i ,..., w x 1 ( , . w i ) ( n p ) , i p ) ,..., x N n 1 i : p x < ∑ k n n P p ,..., w , $ 1 = p ,..., M P 1 , (( , i p i ( ( ( w i ≥···≥

April 17, 2009 x i ) 2 2 < 0 p w ∑ k , recurse − M ≥ , 1 1 1 ˆ M x p w ( bbKnapsack = $ heuristicKnapsack L : Find solutions assuming M = ˆ return // assert Procedure x recurse // x Function Rucksackproblem Beispiel: Branch-and-Bound für das Sanders: Algorithmen I 406 i ) i x p + P , i ) w P ) − , $ $ $ on variable M M M , current Solution , , ) 1 1 n // best solution so far w + + i i // Branch ( ( // ,..., i w ( , ) ; recurse ; recurse n p := 0 := 1 ) i i x x N ,..., : i x p P , (( then $ then := $ ˆ x ˆ x M · rekursive Aufrufe , M April 17, 2009 i p n ( Bound 2 ≤ > i then then w u n ˆ x if if · upper recurse > p i + if else P > u := u if ˆ x Procedure x Schlechtester Fall: Im Mittel: Linearzeit? Sanders: Algorithmen I 407 5 4 3 2 1 B 38 B 38 0??? 38 M 38 01?? 41 0110 C 20 011? 34 ???? B 10?? 41 14 improved solution 1???

April 17, 2009 34

39 24 41 C 1100 C 110? C 11?? no capacity left capacity no bounded 10 C B Beispielrechnung Sanders: Algorithmen I 408 , Abschätzung der (woanders) ) Schnittebenen (ILP), beste Fallunterscheidung optimistische Zuerst vielversprechende Fälle Prioritätsliste Systematische .

April 17, 2009 Wonach soll die Fallunterscheidung stattﬁnden? Einmal suchen reicht (unnötig bei ILP) (Alternative, z. B. Nicht weitersuchen, wenn rekursiv z. B. Lemma-Generierung (Logik),. . . gefundene Lösung erreichbaren Lösungen schlechter als (lokal oder global) (z. B. welche Variable bei ILP) Branch-and-Bound – allgemein Sanders: Algorithmen I Anwendungsspez. Suchraumbeschränkungen: Duplikatelimination: Bounding: Reihenfolge der Fallunterscheidung: Verweigungsauswahl: Branching (Verzweigen): 409 S ∩ ) x ( N is best solution found so far ˆ x S ∈ x x := do ˆ x ˆ x ally chosen element from

April 17, 2009 then ) ˆ x ( heuristic f < ) x ( f not satisﬁed with := some x // if x := ˆ x while ﬁnd some feasible solution 12.5 Lokale Suche – global denken, lokal handeln Sanders: Algorithmen I 410 x := local optimum found ˆ x best solution found so far then ) ˆ x ( f < L ) x ∈ ( x f : L

April 17, 2009 ∩ ) ˆ x // x ( N ∈ x ∃ x // else return if := ˆ x loop Find some feasible solution Hill Climbing Sanders: Algorithmen I 411 50 sin(x)/x 0

April 17, 2009 -50 0 1 0.6 0.4 0.2 0.8 -0.2 -0.4 Problem: Lokale Optima Sanders: Algorithmen I 412 5 4 x 3 2 1 0 0 1

April 17, 2009 2 3 y 4 f 3 2 1 0 6 5 4 5 Gegenbeispiel für Koordinatensuche Warum die Nachbarschaft wichtig ist Sanders: Algorithmen I 413

April 17, 2009 ... Simulated Annealing: physikalische Analogie Tabusuche ! ! ! Auch Verschlechterungen akzeptieren. Jenseits von Hill Climbing Sanders: Algorithmen I 414 anneal crystal glass shock cool

April 17, 2009 liquid

Sanders: Algorithmen I 415 von Lösungskandidaten

April 17, 2009 Population −→ Idee: erben guter Eigenschaften beider Eltern zusätzlich: geschlechtliche Vermehrung. Reproduktion ﬁtter Lösungen Mutation ähnlich lokaler Suche x ! ! ! ! Ausführliche Behandlung würde den Rahmen sprengen. Verallgemeinerung von lokaler Suche: 12.6 Evolutionäre Algorithmen Sanders: Algorithmen I 416 . know how z. B. (I)LP, SAT, Lösungen falls Teilprobleme Hoher Platzverbrauch Werkzeugen heuristiken ergeben Näherungslösungen sind. Optimale . Leistungsfähiges Werkzeug für optimale . Selten optimal. Manchmal Einfach mit Rundungs

April 17, 2009 Einfach und einigermaßen schnell. Optimal falls schnell Instanzen funktionieren. austauschbar und und kleinen Einfach Lösungen. Gute Formulierungen können Einiges erfordern. optimal das Modell passt. nur mit constraint programming. Selbst gute Implementierungen mögen Approximationsgarantien Zusammenfassung Vor- und Nachteile Sanders: Algorithmen I Integer Linear Programming: Dynamische Programmierung: Linear Programming: Systematische Suche: Greedy: 417 h aber . gute Lösungen aber oft Leistungsfähig lokalen Optima Langsam Ähnliche Vor- und Nachteile wie lokale und einfach.

April 17, 2009 einfach aber leidet an Flexibel langsam. Tuning kann unschön werden. für harte Probleme. zielgerichtet. Suche. Durch geschl. Vermehrung potentiell mächtiger aberlangsamer auc und schwieriger gut hinzukriegen. Weniger Hill climbing: Simulated Annealing und Tabu Search:

Sanders: Algorithmen I Evolutionäre Algorithmen: Lokale Suche: