Entwurf & Analyse von Algorithmen · 2019-09-23 · Kapitel 1 Einleitung & Beispiele 1.1 Allgemeine Bemerkungen ” Entwurf & Analyse von Algorithmen“ hat die Entwicklung ” hochqualitativer“

Entwurf & Analyse vonAlgorithmen

Skriptum fur 2 VO (MAT.319) und 1 UE (MAT.320)sowie 3VU (716.325), Version WS 2017/18

Associate Professor Dipl.-Ing. Dr. O. AichholzerInstitut fur Softwaretechnology, TU-Graz

Weitere Informationen zur Lehrveranstaltung,insbesondere Literaturangaben, durchgerechnetePrufungsbeispiele, erganzende Overheadfolien, aktuellePrufungstermine u.s.w. erhalten Sie auf meiner Home-page (http://www.ist.tugraz.at/aichholzer/) unter[Teaching]/[Entwurf und Analyse von Algorithmen]. Aufdieser Seite finden Sie auch weiterfuhrende Links zu Themenfur Projekte, Bakk-, Master- und Diplomarbeiten oder Disser-tationen [Teaching]/[Projektthemen, Diplomarbeiten].

Fur weitere Fragen und Diskussionen, sowohl zur Lehrver-anstaltung, als auch allgemein zum Design von Algorith-men und Datenstrukturen, existiert auch die News-Gruppetu-graz.algorithmen

Danksagung: Teile dieses Skriptums basieren auf Unterlagen vonProf. DI Dr. F. Aurenhammer und Prof. DI Dr. G. Woginger.Ihnen mochte ich hiermit fur die Uberlassung dieser Unterlagendanken. Mein besonderer Dank gilt auch Th. Hagauer fur dasErstellen einer ersten Version dieses Skriptums.

2

Anstatt eines Vorwortes (das ohnehin keiner liest) hiernur etwas Kleingedrucktes, das man ja immer aufmerk-sam lesen soll!

Kleingedrucktes

Dieses Skriptum ist als Erganzung zur Lehrveranstaltung gedacht und daher bewußtkompakt gestaltet. Ohne zusatzliche Erlauterungen in den Vorlesungen sind natur-gemaß viele Passagen nur schwer verstandlich. Daher sollten Sie sich, speziell zurPrufungsvorbereitung, nicht ausschließlich auf das Skriptum verlassen.Ein solches Skriptum wird wohl kaum jemals fehlerfrei sein. Daher beim Lesen im-mer mitdenken und nicht alles blind glauben! Hinweise auf Fehler senden Sie bitte [email protected] oder teilen es mir einfach in oder nach der Vorlesung mit.Zum Schluß noch etwas, warum Sie das Skriptum auch nach bestandener Prufungnicht zum Altpapier geben sollten:

”The next best thing to knowing something is

knowing where to find it“ (Samuel Johnson, 1709-1784)

OA

Inhaltsverzeichnis

I Grundlagen 7

1 Einleitung & Beispiele 91.1 Allgemeine Bemerkungen . . . . . . . . . . . . . . . . . . . . . . 9

1.1.1 Schwierigkeiten beim Entwurf guter Algorithmen . . . . . 91.1.2 Wichtig beim Design guter Algorithmen . . . . . . . . . . 10

1.2 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.2.1 Teilsummenproblem (Scanline-Prinzip) . . . . . . . . . . . 101.2.2 Multiplikation langer Zahlen (Divide & Conquer) . . . . . 131.2.3 Exponentation . . . . . . . . . . . . . . . . . . . . . . . . 151.2.4 Matrix–Multiplikation . . . . . . . . . . . . . . . . . . . . 16

2 Rekursive Zeitgleichungen 192.1 Was sind rekursive Zeitgleichungen? . . . . . . . . . . . . . . . . 192.2 Losungsmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.2.1 Substitutions–Methode . . . . . . . . . . . . . . . . . . . 202.2.2 Iterative Methode . . . . . . . . . . . . . . . . . . . . . . 202.2.3 Master Methode . . . . . . . . . . . . . . . . . . . . . . . 21

3 Dynamisches Programmieren 233.1 Rekursion ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.2 ... versus Dynamisches Programmieren . . . . . . . . . . . . . . . 243.3 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.3.1 Matrizen–Ketten–Multiplikation . . . . . . . . . . . . . . 253.3.2 Langste gemeinsame Teilfolge (lgT) . . . . . . . . . . . . 27

4 Randomisierung 314.1 Randomisierte Suchbaume . . . . . . . . . . . . . . . . . . . . . . 31

4.1.1 Dynamische Datenverwaltung (Worterbuch-Problem) . . 314.1.2 Ein neues Balancierungsschema - Prioritaten . . . . . . . 31

4.2 Randomisierte Analyse . . . . . . . . . . . . . . . . . . . . . . . . 33

II Geometrische Algorithmen 37

5 Schnitt von Liniensegmenten 395.1 Problemdefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . 395.2 Naiver Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . 405.3 Plane-Sweep Algorithmus . . . . . . . . . . . . . . . . . . . . . . 40

4 INHALTSVERZEICHNIS

5.3.1 Implementations-Details . . . . . . . . . . . . . . . . . . . 41

6 Konvexe Hullen 456.1 Problemdefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

6.1.1 Einige direkte Anwendungen und Beobachtungen . . . . . 456.2 Erste optimale Losung (Graham-Scan) . . . . . . . . . . . . . . . 476.3 Iteratives Einfugen . . . . . . . . . . . . . . . . . . . . . . . . . . 49

6.3.1 Randomisierte Analyse . . . . . . . . . . . . . . . . . . . . 50

7 Optimale Triangulierung von Polygonen 537.1 Triangulierung von konvexen Polygonen . . . . . . . . . . . . . . 53

7.1.1 Optimale Triangulierung . . . . . . . . . . . . . . . . . . . 547.1.2 Anzahl Triangulierungen eines konvexen Polygons . . . . 55

7.2 Algorithmus zur optimalen Triangulierung . . . . . . . . . . . . . 577.2.1 Dynamisches Programmieren . . . . . . . . . . . . . . . . 587.2.2 Simple Polygone . . . . . . . . . . . . . . . . . . . . . . . 60

III Graphen Algorithmen 61

8 Einfache Graphen–Algorithmen 638.1 Grundbegriffe der Graphentheorie . . . . . . . . . . . . . . . . . 638.2 Speicherung von Graphen . . . . . . . . . . . . . . . . . . . . . . 658.3 Suchen in Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . 65

8.3.1 Suchen in die Breite (BFS–Breadth First Search) . . . . . 668.3.2 Erkennen bipartiter Graphen . . . . . . . . . . . . . . . . 678.3.3 Suchen in die Tiefe (DFS–Depth First Search) . . . . . . 68

8.4 Planare Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

9 Minimale Spannbaume 719.1 Problemdefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . 719.2 Charakterisieren guter Kanten . . . . . . . . . . . . . . . . . . . 729.3 Methode von Prim [1957] . . . . . . . . . . . . . . . . . . . . . . 739.4 Methode von Kruskal [1956] . . . . . . . . . . . . . . . . . . . . . 75

10 Kurzeste Wege in Graphen 7710.1 Problemdefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . 7710.2 Algorithmus von Dijkstra . . . . . . . . . . . . . . . . . . . . . . 7710.3 Floyd–Warshall Algorithmus . . . . . . . . . . . . . . . . . . . . 79

IV Komplexitatstheorie 81

11 NP–vollstandige Probleme 8311.1 Was sind NP–vollstandige Probleme? . . . . . . . . . . . . . . . . 83

11.1.1 Eigenschaften NP–vollstandiger Probleme . . . . . . . . . 8311.1.2 Geometrisches Rundreiseproblem . . . . . . . . . . . . . . 84

11.2 Einteilung in Problemklassen . . . . . . . . . . . . . . . . . . . . 8411.2.1 Was ist mit Problem gemeint? . . . . . . . . . . . . . . . 8411.2.2 Optimierungsproblem–Entscheidungsproblem . . . . . . . 8411.2.3 Warum Entscheidungsprobleme? . . . . . . . . . . . . . . 85

INHALTSVERZEICHNIS 5

11.3 Fundamentale offene Frage: P?= NP . . . . . . . . . . . . . . . . 86

11.3.1 NP–P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8611.3.2 Polynomial reduzierbar . . . . . . . . . . . . . . . . . . . 8611.3.3 NP–Vollstandigkeits–Beweis . . . . . . . . . . . . . . . . . 87

11.4 Beispiele NP–vollstandiger Probleme . . . . . . . . . . . . . . . . 8711.4.1 Traveling Salesman Problem (TSP) . . . . . . . . . . . . . 8711.4.2 Hamiltonscher Kreis . . . . . . . . . . . . . . . . . . . . . 8811.4.3 SAT (formula SATisfiability) . . . . . . . . . . . . . . . . 88

12 Naherungsalgorithmen fur NP–vollstandige Probleme 8912.1 Problemdefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

12.1.1 Relativer Fehler . . . . . . . . . . . . . . . . . . . . . . . . 8912.1.2 Beispiel Geometrische Rundreise (≈ TSP) . . . . . . . . . 90

12.2 Polynomiales Approximationsschema . . . . . . . . . . . . . . . . 9012.3 Naherungslosung fur das Rucksackproblem . . . . . . . . . . . . 91

V Ausgewahlte Kapitel 93

13 String–Matching Verfahren 9513.1 Problemdefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . 9513.2 Grundlegende Algorithmen . . . . . . . . . . . . . . . . . . . . . 95

13.2.1 Naiver Algorithmus . . . . . . . . . . . . . . . . . . . . . 9513.2.2 Algorithmus von Knuth, Morris, Pratt (1977) . . . . . . . 9713.2.3 Verfahren von Karp–Rabin (1981) . . . . . . . . . . . . . 98

13.3 Effiziente Verfahren in der Praxis . . . . . . . . . . . . . . . . . . 10013.3.1 Quicksearch . . . . . . . . . . . . . . . . . . . . . . . . . . 10013.3.2 Optimal–Mismatch . . . . . . . . . . . . . . . . . . . . . . 100

14 Parallele Algorithmen 10314.1 Problemdefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . 10314.2 Wichtige Maße fur die Effizienz paralleler Algorithmen . . . . . . 10314.3 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

14.3.1 Paralleles Berechnen von Prafixsummen . . . . . . . . . . 10414.3.2 Parallele Addition von n Zahlen . . . . . . . . . . . . . . 106

VI Anhang 107

A Ubungsbeispiele 109

Alphabetischer Stichwortindex 116

6 INHALTSVERZEICHNIS

Teil I

Grundlagen

Kapitel 1

Einleitung & Beispiele

1.1 Allgemeine Bemerkungen

”Entwurf & Analyse von Algorithmen“ hat die Entwicklung

”hochqualitativer“

Datenstrukturen und Programmierverfahren zum Ziel. Hauptkriterien fur Qua-litat sind Korrektheit, Laufzeit und Speicherbedarf. Warum? Selbst ein-fache Problemstellungen fuhren, wenn ungeschickt programmiert, auf enormeRechenzeiten! Und trotz der rasanten Hardware Entwicklung lassen sich kom-plexeren Problemen meist nur durch geschicktes Algorithmendesign losen, nichtjedoch durch die Anschaffung von mehr Rechenleistung. Dies wird klar, wennman den oft exponential ansteigenden Resourcenbedarf naiver Implementatio-nen betrachtet. Hier kann dann auch tausendfache Rechenleistung keine ernstzu-nehmenden Problemgroßen bearbeiten, ein geschickter polynomialer Algorith-mus auf einem herkommlichen PC jedoch in Sekundenbruchteilen zur Losungfuhren und ihn damit jeder Großrechenanlage uberlegen machen.

Die Lehrveranstaltung”Entwurf & Analyse von Algorithmen“ macht es sich

zum Ziel anhand von konkreten Beispielen Methoden zum Entwurf und zurAnalyse von effizienten Datenstrukturen und Algorithmen zu veranschaulichen.Besonderer Wert wird dabei darauf gelegt die zugrundeliegenden Denkweisenaufzuzeigen, da

”spater in der Praxis“ wohl kaum die gleichen Probleme auftre-

ten werden, die gelernten Methoden und Verfahren aber durchaus angewandtwerden konnen. Besonders wichtig ist es auch durch die Beschaftigung mit ver-schiedenen Analysemethoden Einblick in (oder vielleicht besser

”Gespuhr fur“)

die Realisierbarkeit (oder eben Unrealisierbarkeit - siehe NP-Vollstandigkeit)effizienter Losungen zu erhalten - etwas das einen Universitatsabganger vomreinen Programmierer unterscheiden sollte.

1.1.1 Schwierigkeiten beim Entwurf guter Algorithmen

Direkte Programmierung (von komplexeren Formeln etc.) bringt oft hohe Lauf-zeit. Andererseits sind effiziente Methoden oft nicht intuitiv.

• Wie kommt man auf die richtige Idee? (Entwurfsprinzipien probieren,Analogien zu bekannten Problemen)

• Laufzeit–Analyse meist schwierig! (grobeO–Schranke leicht, richtiges Wachs-tum oft schwer)

10 KAPITEL 1. EINLEITUNG & BEISPIELE

• Korrektheit nicht offensichtlich. (Analyse problemspezifischer Eigenschaf-ten, Speziallfalle)

1.1.2 Wichtig beim Design guter Algorithmen

• Entwurfsprinzipien: Divide & Conquer, Scanline Prinzip, Rekursion, Dy-namisches Programmieren, Greedy–Algorithmus . . .

• Datenstrukturen: Heap, Stack, Schlange, Baume, Warteschlange, Geome-trische Datenstrukturen . . .

• Laufzeit– und Speicheranalyse: asymptotisches Verhalten. O–, Ω–, Θ– No-tation, Worstcase– und Mittlerer Fall, randomisiertes Verhalten . . .

• Realisierbarkeit: Ist ein effizienter Algorithmus moglich? NP– Vollstandigkeit,Untere Laufzeitschranke, . . .

• Korrektheit: Garantie fur Laufzeit-/Speicherschranken, Spezialfalle (’ent-arteter’ Input), mittleres Verhalten, . . .

Im Folgenden sollen anhand von einfachen Beispielen die Wichtigkeit guterEntwicklungskonzepte fur Algorithmen verdeutlicht werden. Dabei werden zu-erst sehr schlechte Losungen prasentiert, um dann Schritt fur Schritt zu immereffizienteren Verfahren zu kommen. Zum Schluß werden Uberlegungen gezeigt,die zur (beweisbar) optimalen Losung fuhren. Es ist eine gute Ubung sich zuuberlegen, welche Losung man ohne Hilfe selbst gefunden hatte ...

1.2 Beispiele

1.2.1 Teilsummenproblem (Scanline-Prinzip)

Es werden nun anhand des Teilsummenproblems 1 drei simple Methoden ge-zeigt, wie unterschiedlich dieses Problem gelost werden kann. Als vierte Methodewird dann das viel effizientere Scanline Prinzip verwendet. (Nachzulesen z.B.in Kapitel 7 der “Programming Pearls”, Jon Bentley, Addison-Wesley,1986)

Gegeben: Lineares Feld A[1..n] ganzzahlig (auch negative Zahlen!)Gesucht: zusammenhangende Teilfolge mit maximaler Summe.

Beispiel: 4, −5, 4, 2, − 3⇒ Summe=6

A

1 i nj

1Hinweis: Zu diesem Kapitel gibt es auf der Lehrveranstaltungshomepage zur Veranschau-lichung einen animierten Algorithmus.

1.2 Beispiele 11

Methode 1

Alle moglichen Teilmengen von n Elementen betrachten und auf Zusammen-hang testen: 2n Teilmengen ⇒ Zeit O(n ∗ 2n)n . . . Summe uber Teilmengen2n . . . Anzahl der Teilmengenz.B. Rechner mit 106 Op/s: n = 1000 ⇒≈ 10304 Operationen ⇒≈ 10290 JahreRechenzeit! (Bei einer Million Elemente ca. 10300000 Jahre ...)

Methode 2

Beschrankung auf zusammenhangende Teilfolgen:

max1≤i≤j≤n

j∑

k=i

A[k], 0

0 falls nur negative Zahlen → Leere Teilfolge optimal.

Pseudo Code:max := 0; von := 0; bis := 0; /* Merker fur bisher beste Folge */for i := 1 to n do

for j := i to n dosum := 0;for k := i to j do

sum := sum+A[k];odif sum > max then max := sum; von = i; bis = j;fi

ododwrite(“A[”, von, “-”, bis, “] max. Summe=”,max)

Analyse:i, j, k durchlaufen maximal n Schrittedrei ineinander verschachtelte Schleifen ⇒ O(n3) Schrittefur n = 1000⇒ 109 Schritte ⇒ (mit gleichem Rechner 106 op/s) ca. 16min.Besser, aber immer noch zu langsam!

Methode 3

Die Summe wird”Online“ mit j berechnet:

Pseudo Code:


max := 0; von := 0; bis := 0;for i := 1 to n do

sum := 0;for j := i to n do

sum := sum+A[j];if sum > max then max := sum; von = i; bis = j;fi

ododwrite(“A[”, von, “-”, bis, “] max. Summe=”,max)

Analyse:i und j durchlaufen hochstens n Werte ⇒ O(n2) SchritteFur n = 1000⇒ 106 Schritte ⇒ 1sec mit gleichem Rechner.

Optimal? Nein!

Methode 4: SCANLINE PRINZIP

Durchlauf des Inputs durch eine sogenannte”Scanline“ (einmal) und man be-

trachtet zu jedem Zeitpunkt nur jenen Teil des Inputs, der von der Scanlineerfaßt wird.→ Idee: Berechne fur jeden Index k die maximale Teilfolge Tk die bei k endet.⇒ Dann existiert ein k mit (globaler) maximaler Teilsumme. Dieses mussen wirermitteln.

Beobachtungen:

TK ≥ 0,

Tk = maxTk−1 +A[k], 0

Pseudo Code:max := 0; von := 0; bis := 0; v := 1; T := 0for k := 1 to n do

T := T +A[k]if T < 0 then T := 0; v = k + 1fiif T > max then max := T ; bis := k; von := vfi

odwrite(“A[”, von, “-”, bis, “] max. Summe=”,max)

Dabei legt v den Beginn der aktuell betrachteten Folge fest und T spielt dieRolle von Tk. Der Algorithmus benotigt nur O(n) Zeit, also nicht viel mehr Zeitals das Einlesen von A[1 . . . n]. Dies ist daher offensichtlich optimal (der gesamteInput muß ja gelesen werden, denn nur eine geanderte Zahl kann das Ergebnisverandern!).Fur n = 1000⇒ 103 Schritte ⇒ 1/1000 sec! auf gleichen Rechner (Und fur eineMillion Elemente nur ca. 1 Sekunde!)

1.2 Beispiele 13

Beispiel:

– 2 3 1 -4 1 -3 2 -6 -3 1 8Tk 2 5 6 2 3 0 2 0 0 1 9von 1 1 1 1 1 1 1 1 1 1 10bis 1 2 3 3 3 3 3 3 3 3 11v 1 1 1 1 1 1 1 9 10 10 10k 1 2 3 4 5 6 7 8 9 10 11

1.2.2 Multiplikation langer Zahlen (Divide & Conquer)

Es sollen zwei n–stellige Zahlen multipliziert werden. Dabei ist n so groß, daßdie Zahlen nicht in eine Variable passen (Prazisionsarithmetik, viele signifikanteStellen).Seien p und q zwei n–stellige Dezimalzahlen, gespeichert in den Feldern p =P [1..n] und q = Q[1..n].

p =

n∑i=1

P [i] ∗ 10n−i

q =n∑

i=1

Q[i] ∗ 10n−i

D.h. p1 ist “most significant byte” und pn ist “least significant byte”

Gesucht ist ein effizientes Verfahren fur p ∗ q!

Methode 1: Schulmethode

BA

Ergebnis

n ∗ n”Einmaleins“ – Operationen (plus Additionen)⇒ O(n2)Zeit.

Es sieht so aus, als ob diese Methode nicht zu schlagen ware. Stimmt nicht!

Methode 2: Divide & Conquer

Das folgende ungewohnliche Multiplikationsschema beruht auf dem Entwurfs-prinzip Divide & Conquer:p wird in Teilzahlen a und b zerlegt: p = a∥b = a ∗ 10n/2 + bq wird in Teilzahlen c und d zerlegt: q = c∥d = c ∗ 10n/2 + d


p ∗ q = a ∗ c ∗ 10n + (a ∗ d+ c ∗ b) ∗ 10n/2 + b ∗ d

⇒ 4 Operationen mit n/2 Stellen (fur 10x genugt eine einfache shift-Operation)⇒ Zuruckfuhrung der Multiplikation zweier Zahlen mit n Stellen auf 4 Multi-plikationen mit n/2 Stellen.

Analyse:

T (n) = 4 ∗ T (n/2) +O (n)

= 4 (4T (n/4) +O (n/2)) +O (n)

= 16T (n/4) + 2O (n) +O (n)

= · · · = 4kT(n/2k

)+O (n)

k−1∑i=0

2i

k=ld(n)= 4ld(n)O(1) +O(n) ∗O(n) = O

(n2)

D&C allein genugt also nicht. Folgender arithmetischer Trick hilft weiter:

Methode 3: Verbessertes Divide & Conquer

Wir berechnen u = ac; v = bd; w = (a + b)(c + d) Das sind drei Multipli-kationen von n/2–stelligen Zahlen. Wir brauchen noch ad+ bc.

(ad+ bc) = ad+ ac+ bd+ bc− ac− bd

= (a+ b)(c+ d)− ac− bd

= w − u− v

⇒ Keine weiteren Multiplikationen notwendig. Additionen konnen in O(n) Zeitdurchgefuhrt werden. Gesamt ergibt sich daher:

T (n) = 3T (n/2) +O(n)

= 3[3T (n/4) +O(n/2)] +O(n)

= 32T (n/22) + 31O(n/21) + 30O(n/20) = · · · =

= 3kT (n/2k) +k−1∑i=0

3iO(n/2i) = (setze k = ldn)

= O(3ldn) +O(n)ldn−1∑i=0

(3/2)i = (beachte:∑k−1

i=0 qi = qk−1q−1 )

= O(nld3)

Die Laufzeit betragt somit O(3k) fur k = ld(n), gleich O(nld3) ≈ O(n1.59) ,also ein wenig mehr als O(n

√n). Damit kann die Multiplikation von zwei n-

stellige Zahlen wesentlich schneller als mit der Schulmethode (quadratisch vieleSchritte) durchgefuhrt werden!

1.2 Beispiele 15

1.2.3 Exponentation

Berechne xn, x ∈ R, n ∈ N moglichst effizient!Beispiel: x23

• trivial: 22mal multiplizieren

• besser:

x ∗ x→ x2

x2 ∗ x2 → x4

→ x8

→ x16

x23 = x16 ∗ x4 ∗ x2 ∗ x1

⇒ 7 Multiplikationen

Idee:

• Berechne x2, x4, x8, x16 . . . x2k , k = ⌊ld(n)⌋durch wiederholtes Quadrieren.

• Multipliziere jene Terme x2i , fur die in der Binardarstellung (bk, bk−1, . . . , b1, b0)von n an der Stelle i ein 1er steht, d.h. bi = 1 gilt.⇒≤ 2 ∗ ⌊ld(n)⌋ = O(log(n)) Multiplikationen.

Die folgende Funktion berechnet xn nach dieser Methode:

FUNCTION EXP (x, n) : REALe := 1while n > 0 do

if (ungerade(n)) then e := e ∗ x fin:=n DIV 2(ganzzahlig)if n > 0 then x := x ∗ x fi

odEXP := e

Beispiel x62

x2; x4; x8; x16; x32

x62 = x2 ∗ x4 ∗ x8 ∗ x16 ∗ x32 ⇒ 9 Multiplikationen

Es sieht so aus als ware diese Methode optimal, jedoch geht es in diesemFall sogar noch besser:

x62 = x20 ∗ x20 ∗ x20 ∗ x2

x20 = x16 ∗ x4

x2; x4; x8; x16 ⇒ 8 Multiplikationen


Das Finden der tatsachlich optimalen Losung fur beliebige Eingabe ist einnoch offenes Problem!2

1.2.4 Matrix–Multiplikation

Bei sehr vielen Computerverfahren spielt die effiziente Berechnung von Matri-zenprodukten eine sehr zentrale Rolle, so z.B. in der Numerik (Wettervorhersa-ge, Stromungssimulationen etc.), Computergraphik (Lichtverteilung, Oberflacheneigenschaften),Optimierung (Kostenmatrizen) u.v.a.

Beispiel: Multiplikation von 2× 2 Matrizen:(r st u

)=

(a bc d

)∗(e gf h

)r = ae+ bf

s = ag + bh

t = ce+ df

u = cg + dh

Mit der bekannten Schulmethode sind 8 Multiplikationen und 4 Additionen not-wendig. Geht es besser?

JA! → Mit der sog. Strassen–Methode!

p1 = a(g − h)

p2 = (a+ b)h

p3 = (c+ d)e

p4 = d(f − e)

p5 = (a+ d)(e+ h)

p6 = (b− d)(f + h)

p7 = (a− c)(e+ g)

s = p1 + p2

t = p3 + p4

u = p5 + p1 − p3 − p7

r = p5 + p4 − p2 + p6

︸︷︷︸7 Multiplikationen, 18 Additionen

Dieser Ansatz laßt sich nun einfach auf großere Matrizen verallgemeinern: SeienA und B zwei n× n Matrizen mit n = 2k, k ∈ N 3 und C = A ·B ihr Matrizen-produkt. Mit der Schulmethode werden O(n3) Multiplikationen zur Berechnungvon C benotigt.

Idee:

C =

(C11 C12

C21 C22

)=

(A11 A12

A21 A22

)·(B11 B12

B21 B22

)2Mehr dazu unter dem Stichwort minimal addition chains z.B. in Knuths bekanntem Buch

“The art of computer programming” Vol. 2, Kapitel 4.6.3.3Gegebenenfalls konnen die Matrizen auf die nachstgroßere, passende Dimension k “auf-

gefullt” werden

1.2 Beispiele 17

mit Cij = Ai1 ·B1j +Ai2 ·B2j

⇒ Berechne das Produkt zweier n×n Matrizen durch Reduktion auf n/2×n/2Matrizen, analog der

”einfachen“ 2× 2 Matrizenmultiplikation.

• Mit Schulmethode:8 n/2× n/2 Matrizenmultipikationen notwendig⇒ T (n) = 8T (n/2) +O(n2)︸︷︷︸

fur Matrizen–Addition⇒ O(n3) Multiplikationen ⇒ keine Verbesserung.

• Mit Strassen–Methode:Nur 7 n/2× n/2 Matrizenmultipikationen notwendig⇒ T (n) = 7T (n/2) +O(n2) = · · · =

= O(nld7) = O(n2.81)

Die Strassen-Methode eignet sich daher gut fur sehr große Matrizen undwird dort auch erfolgreich eingesetzt.

Anmerkung: Es gibt zum Multiplizieren großer Matrizen noch effizientereVerfahren, speziell wenn die Matrizen gunstige Eigenschaften aufweisen wie z.B.daß sie nicht voll besetzt sind (d.h. viele 0-Eintrage enthalten). Die beste der-zeit bekannte Methode fur den allgemeinen Fall hat eine Laufzeit O(n2.373).Trivialerweise gilt die untere Laufzeitschranke Ω(n2).


Kapitel 2

Rekursive Zeitgleichungen

2.1 Was sind rekursive Zeitgleichungen?

Rekursive Zeitgleichungen sind Gleichungen oder Ungleichungen, die eine Funk-tion durch sich selbst mit kleineren Parameterwerten beschreiben. Dabei muß essich nicht notwendigerweise um Gleichungen handeln die Zeitzusammenhangebeschreiben. So konnen diese Gleichungen auch bei der Speicheranalyse oderbei Untersuchungen kombinatorischer Eigenschaften etc. auftreten. ZahlreicheLosungsmethoden wurden jedoch im Zusammenhang mit Zeitgleichungen be-kannt, daher diese Namensgebung.

z.B.: fur Merge–Sort:

T (n) =

Θ(1) fur n = 1

2T (n/2) + Θ(n) fur n ≥ 2

⇒ Losung: T (n) = Θ(n · log n)

Gesucht werden asymptotische Θ bzw. O Schranken fur die gegebenen Funk-tionen. Zur Vereinfachung wird oft T (n) = O(1) fur kleine n angenommen,d.h. der Anfangswert von Funktionen, T (c) = O(1), c konstant, wird oft nichtexplizit angegeben. Weiters werden Terme der Form n

2 oft statt ⌊n2 ⌋ und ⌈n2 ⌉

geschrieben (Merge–Sort etwa exakt: T (n) = T (⌈n2 ⌉) + T (⌊n2 ⌋) + Θ(n))

2.2 Losungsmethoden

Im Folgenden sollen drei einfache Methoden zur Losung einer großen Klasse vonrekursiven Zeitgleichungen vorgestellt werden. Dabei sind nicht alle Methodenfur alle Aufgaben gleich gut geeignet, ja es gibt auch durchaus einfache rekursiveZeitgleichungen die mit keiner der folgenden Methoden gelost werden konnen.

Als einfache Ubung versuche z.B. die rekursive Gleichung T (n) = 9T (n3 ) +5n2 mit den einzelnen Methoden zu losen und vergleiche den Aufwand unddie Ergebnisse. Weitere Beispiele sind T (n) = T (n2 ) + O(1) (Binarsuche) undT (n) = 3T (n2 ) +O(n) sowie T (n) = 7T (n2 ) +O(n2) (aus Kapitel 1).

20 KAPITEL 2. REKURSIVE ZEITGLEICHUNGEN

2.2.1 Substitutions–Methode

Hier wird versucht, das asymptotische Verhalten zu”erraten“ (z.B. Vergleich

mit bereits gelosten Zeitgleichungen) und anschließend durch mathematischeInduktion zu beweisen.

Beispiel

T (n) = 2T (⌊n2⌋) + n

Sieht ahnlich wie die Zeitgleichung eines guten Sortierverfahrens aus, daher

”Vermutung“: T (n) = O(n log n)

Wir haben zu zeigen: ∃c > 0, n0 ∈ N, k ∈ Rsodaß T (n) ≤ c · n logn+ k fur n ≥ n0

T (n) ≤ 2(c⌊n

2⌋ log(⌊n

2⌋))+ n (nach (impliziter) Induktionsvoraussetzung)

≤ c · n log(n

2) + n

= c · n log n− c · n log 2 + n

= c · n log n− c · n+ n (log ∼= ld)

≤ c · n log n (fur c > 1, k wurde hier 0 gesetzt)

D.h. fur c > 1 ist T (n) = O(n log n) fur n ≥ n0 = 2 und die Vermutung istsomit bewiesen.

Achtung:”Vermutung“ fur obiges Beispiel T (n) = O(n)

⇒ z.Z. ware ∃c > 0, n0 ∈ N : T (n) ≤ c · n fur n ≥ n0

T (n) ≤ 2(c · ⌊n2 ⌋) + n ≤ cn+ n = O(n) . . .⇒ FALSCH!!!cn+n = (c+1)n, d.h. es gibt hier kein c, sodaß T (n) ≤ cn gilt! Bei vollstandigerInduktion immer die exakte, nicht die asymptotische Form beweisen! (Die Ana-lyse asymptotischer Zusammenhange wird manchmal auch als “Kunst des Wis-sens was man weglassen darf (und was nicht)” bezeichnet.)

Ein Nachteil der Substitutions-Methode ist, daß die Vermutung nicht “scharf”sein muß, d.h. die Schranke kann ggf. noch verbessert werden. Unter Umstandenmussen daher mehrere Ansatze versucht werden. Weiters sollte zusatzlich aucheine untere Grenze gezeig werden, um eine scharfe Schranke garantieren zukonnen.

2.2.2 Iterative Methode

Bei der iterativen Methode wird durch wiederholtes Einsetzen der Rekursioneine Summendarstellung erzeugt. Dadurch kann die Zeitgleichung durch Schran-ken fur (unendliche) Summen begrenzt werden.

2.2 Losungsmethoden 21

Beispiel:

T (n) = 2T (n

2) + n2 = 2(2T (

n

4) + (

n

2)2) + n2

= 4T (n

4) +

n2

2+ n2

= 4(2T (n

8) + (

n

4)2) +

n2

2+ n2 = 8T (

n

8) +

n2

4+

n2

2+ n2

= . . .

= 2kT (n

2k) +

n2

2k−1+ · · ·+ n2

2+ n2

Ausn

2k!= 1 folgt k = log n

⇒ T (n) ≤ O(n) +

k−1∑i=0

n2

2i≤ O(n) + n2

∞∑i=0

1

2i︸︷︷︸ = O(n) + 2n2 = O(n2)

2

Diese Methode kommt oft bei einfachen Zusammenhangen zum Einsatz, dasie ohne großen formalen Aufwand durchfuhrbar ist, siehe z.B. die Lehrveran-staltung Datenstrukturen und Algorithmen.

2.2.3 Master Methode

Die Master Methode liefert ein einfaches “Kochrezept” fur Rekursionen derForm

T (n) = aT (n

b) + f(n)

a ≥ 1; b > 1

Dabei gibt es drei Losungsmoglichkeiten:

1. f(n) = O(nlogb a−ϵ

)fur ϵ > 0

⇒ T (n) = Θ(nlogb a)

2. f(n) = Θ(nlogb a)⇒ T (n) = Θ(nlogb a log n)

3. f(n) = Ω(nlogb a+ϵ

)fur ϵ > 0 und

∃c < 1 sodaß a · f(nb ) ≤ c · f(n), n ≥ n0

⇒ T (n) = Θ(f(n))

Losungsvorgang:

1. logb a berechnen

2. Entsprechenden Fall (1.-3.) betrachten

Beispiel:

T (n) = 2T (n/2) + Θ(n)

22 KAPITEL 2. REKURSIVE ZEITGLEICHUNGEN

a = 2, b = 2, Fall 2)⇒ T (n) = Θ(nld(2) log n) = Θ(n log n)

BeispielT (n) = 2T (n/2) + Θ(n2)

a = 2, b = 2, Fall 3), ϵ = 1

2(n/2)2= (1/2)n2

!≤ cn2 ⇒ c ≥ (1/2)⇒ ∃c < 1

⇒ T (n) = Θ(n2)

Beispiel:T (n) = 2T (n/2) + n log n

a = 2, b = 2, aber n log n mußte polynomiell großer als n sein um Fall 3) zuerfullen. Dies ist nicht der Fall, da es kein ϵ > 0 gibt, fur das n logn

n = log nasymptotisch großer als nϵ ist!!⇒ Master Methode hier nicht anwendbar!!

Kapitel 3

DynamischesProgrammieren

3.1 Rekursion ...

Immer wenn ein Problem durch Zerlegung in kleinere Teilprobleme gelost wer-den kann, scheint ein rekursiver Algorithmus geeignet zu sein. Aber Achtung:Mussen identische Teilprobleme mehrfach gelost werden, so fuhrt die Rekursi-on zu unnotigem Mehraufwand, der zu exponentiell ansteigender Laufzeit fuhrenkann.Beispiel: Berechnung der Fibonacci1–Zahlen fn rekursiv:

fn = fn−1 + fn−2, f1 = f2 = 1

fn−4 fn−5

%% ee

fn−3 fn−4

%%bbb

fn−2

fn−4 fn−5

%% ee

fn−3

"""aaaa

fn−1

fn−4 fn−5

%% ee

fn−3

fn−5 fn−6

%% ee

fn−4

"""bbb

fn−2

XXXXXXX

fn

. . . usw. . . .

fn−4 wird hier z.B. bereits funffach berechnet. Wie z.B. aus D&A bekanntfuhrt dieses Verfahren auf exponentielle Laufzeit!

Beobachtung: Berechnet man zuerst die kleineren Funktionswerte und spei-chert diese, so konnen großere Funktionswerte durch einfachen Speicherzugriffermittelt werden. Eine Mehrfachberechnung wird somit vermieden! Diese Beob-achtung fuhrt zum Schema des dynamischen Programmierens.

1sprich ’fibonatschi’

24 KAPITEL 3. DYNAMISCHES PROGRAMMIEREN

3.2 ... versus Dynamisches Programmieren

Kann ein Problem durch Zerlegung in kleinere Probleme gelost werden und sinddiese aber nicht voneinander unabhangig (d.h. dieselben Teilprobleme konnenofter auftreten), so kann oft das sogenannte dynamische Programmieren alsLosungsansatz verwendet werden:

Beginnend mit den kleinsten Teilproblemen, berechne deren Losung und speiche-re sie derart, daß großere (Teil–) probleme durch Speicherzugriff auf die bereitsberechneten Losungen ihrer Teilprobleme berechnet werden konnen. Wiederholedies, bis das ursprungliche Problem gelost ist.

• Vorteil: Jedes Teilproblem muß nur einmal berechnet werden.

• Nachteil: Eventuell zusatzlicher Speicheraufwand, um Losungen zwischen-zuspeichern. Oft ist der Speicheraufwand jedoch gering, da jeweils nur dieLosung von einem Teil der bearbeiteten Teilprobleme benotigt wird. (sieheBeispiele)

... und nochmals Fibonacci

f1 = 1 f3 = f2 + f1 = 2f2 = 1 f4 = f3 + f2 = 3

f5 = f4 + f3 = 5. . . usw. . . .fn = fn−1 + fn−2

Es werden jeweils nur die Werte von fn−1 und fn−2 benotigt, d.h. zwei Spei-cherplatze genugen, altere Werte konnen uberschrieben werden.⇒ Mit diesem Ansatz wird fn in O(n) Zeit und O(1) Speicher berechenbar.

Typisches Verhalten von Problemen die fur

Teilprobleme

Dynamisches Prog.D&C

geeignet sind.

3.3 Beispiele

Es folgen nun einige einfache Anwendungen dieses Algorithmen-Designprinzips.Weiter Anwendungen finden sich z.B. im Kapitel 7 uber optimale Triangulie-rungen.

3.3 Beispiele 25

3.3.1 Matrizen–Ketten–Multiplikation

Gegeben ist eine Folge von n Matrizen A1, . . . , An der Große p0 × p1, p1 ×p2, . . . , pn−1 × pn (Ak hat also Große pk−1 × pk)

Gesucht ist ein effizientes Verfahren zur Berechnung des Matrizenproduk-tes 2 3 A1 ·A2 · · · · ·An.

Einige wichtige Beobachtungen:

• Matrizenmultiplikation ist assoziativ, d.h. unterschiedliche “Klammerun-gen” liefern gleiche Ergebnisse.

• Verschiedene Klammerungen benotigen unterschiedliche Rechenzeit!

• Gesucht ist daher die effizienteste Multiplikations–Reihenfolge!!

• Um eine p×q Matrix mit einer q×r Matrix zu multiplizieren, sind (Schul-methode) p · q · r

”skalare“ Multiplikationen notwendig.

Beispiel:A1 = 10× 100A2 = 100× 5A3 = 5× 50

((A1A2)A3) : A1 ·A2︸︷︷︸ : 10× 100× 5 = 5000

(10× 5) ·A3 : 10× 5× 50 = 25007500

(A1(A2A3)) : A2 ·A3︸︷︷︸ : 100× 5× 50 = 25000

A1 · (100× 50) : 10× 100× 50 = 5000075000

Schlechte Wahl der Reihenfolge verursacht hier zehnfachen Aufwand.

Im Folgenden betrachten wir daher verschiedene Methoden um die optimaleKlammerung und somit die optimale Multiplikationsreihenfolge zu finden.

Methode 1:”Brute–force“ Die Folge von n Matrizen kann an jeder Stel-

le in zwei Teile getrennt werden ((. . . )·(. . . )), die dann rekursiv weiter zerlegtwerden konnen. Als Anzahl moglicher verschiedener Klammerungen folgt daher:

P (n) =

1 fur n = 1n−1∑k=1

P (k)P (n− k) fur n ≥ 2


3Vergleiche dies mit dem Problem der Matrizenmultiplikation, Kapitel 1.2.4. Die beidenMethoden konnen auch kombiniert werden.


Als Losung ergeben sich hier die sogenannten Catalan–Zahlen C(n):4

P (n) = C(n− 1) mit C(n) =1

n+ 1

(2n

n

)= Θ

(4n

n1.5

)Eine einfache Betrachtung aller Moglichkeiten mittels “brute–force” wurde al-so exponentielle Laufzeit benotigen und ist daher fur umfangreichere Aufgabennicht moglich!

Methode 2: Dynamisches ProgrammierenMit m[i, j] wird die minimale Anzahl von benotigten skalaren Multiplikationendes Teilproblemes fur die Matrizen Ai, Ai+1, . . . , Aj bezeichnet. m[1, n] stelltalso die gunstigsten “Kosten” fur unser Problem dar. Fur m[i, j] gilt folgenderZusammenhang (zur Erinnerung: Ai hat die Große pi−1 × pi):

m[i, j] =

0 fur i = j (nur eine Matrix)

mini≤k<j

m[i, k] +m[k + 1, j] + pi−1pkpj fur i < j

Der rekursive Zusammenhang wird durch folgende Beobachtung klar: Wird eineoptimale Losung furAi, Ai+1, . . . , Aj in zwei Teilfolgen (Ai, . . . , Ak) (Ak+1, . . . , Aj),i ≤ k < j geklammert, so mussen auch die Teilfolgen optimal sein.

Eine direkte rekursive Implementierung dieser Beobachtung wurde (wie bei denFibonacci–Zahlen) auf exponentielle Laufzeit fuhren. Daher verwenden wir dy-namisches Programmieren:

Mit s[i, j] wird der Index bezeichnet, der zur optimalen “Teilung” von Ai, . . . , Aj

fuhrt (“minimales k”). Man betrachtet nun “bottom up” immer langerer Teil-probleme:

Pseudo Code:

for i := 1 to n dom[i, i] := 0

odfor l := 2 to n do

for i := 1 to n− l + 1 doj := i+ l − 1m[i, j] :=∞for k := i to j − 1 do

hlp := m[i, k] +m[k + 1, j] + pi−1pkpjif hlp < m[i, j] then

m[i, j] := hlps[i, j] := k

Beachte: Der Algorithmus berechnet die Kosten fur immer langer werdende Teil-folgen (l..Lange des Teilproblemes Ai . . . Aj ; Anfangslange 1, Endlange n) nur

4Catalan–Zahlen besitzen eine große Bedeutung innerhalb der Kombinatorik (“Top–Ten” der wichtigsten kombinatorischen Zahlen). Siehe auch Kapitel 7.1.2 sowie z.B.:http://www-groups.dcs.st-and.ac.uk/∼history/Miscellaneous/CatalanNumbers/catalan.html

3.3 Beispiele 27

durch Zugriff auf bereits berechnete Werte, also ohne Rekursion!

Zeitanalyse: 3 geschachtelte FOR–Schleifen ⇒ O(n3) Zeit (anstatt O(4n) beiBrute-force).

Speicheranalyse: fur m[. . . ] und s[. . . ]⇒ Θ(n2) Speicher.

Die minimale Anzahl von Multiplikationen steht in m[1, n]. Aus s[i, j] kanndie optimale Multiplikationsreihenfolge (Klammerung) leicht rekonstruiert wer-den:

FUNKTION KLAMMERUNG(i, j) : STRINGx, y : STRINGif i < j then

x := KLAMMERUNG(i, s[i, j])y := KLAMMERUNG(s[i, j] + 1, j)RETURN(”(”, x, y, ”)”)

elseRETURN(”Ai”)

Aufruf: KLAMMERUNG(1,n);

Analyse: O(n), da jede Matrix Ai und jedes Klammerpaar nur einmal betrachtetwird.

Gesamt ergibt sich daher folgender

Satz: Die optimale Klammerung zur Multiplikation von n Matrizen A1, . . . , An

kann in O(n3) Zeit und O(n2) Speicher berechnet werden.

3.3.2 Langste gemeinsame Teilfolge (lgT)

Seien X = (x1, x2, . . . , xm) und Z = (z1, z2, . . . , zk), k ≤ m zwei (Zeichen–)Folgen. Dann ist Z eine Teilfolge 5 von X, wenn es eine sortierte Indexfolgei1, i2, . . . , ik gibt, sodaß zj = xij fur j = 1..k gilt.

Beispiel: X = (a, b, c, d, a, c, b, a, d)Dann ist Z = (a, d, c, a) eine Teilfolge mit i1 = 1, i2 = 4, i3 = 6, i4 = 8.Y = (d, c, a, b) ist keine Teilfolge.

Problem der langsten gemeinsamen Teilfolge (lgT) 6

Gegeben sind zwei Folgen X und Y und gesucht ist die langste Folge, die sowohlvon X als auch von Y Teilfolge ist.

Beispiel: X = (a, b, c, b, d, a, b); Y = (b, d, c, a, b, a)


6Achtung: Bitte nicht mit Kapitel 1.2.1 verwechseln!


Dann ist z.B. (b, c, a) eine Teilfolge von X und Y , aber (b, c, b, a) oder (b, d, a, b)sind langere Teilfolgen.

Wir bezeichnen mitXi = (x1, . . . , xi) denPrafix der FolgeX = (x1, . . . , xm),i ≤ m. Dann gilt folgende Beobachtung:

Sei Z = (z1, . . . , zk) die langste gemeinsame Teilfolge von X = (x1, . . . , xm)und Y = (y1, . . . , yn), dann gilt:

1. Falls xm = yn dann ist zk = xm = yn und Zk−1 ist lgT von Xm−1 undYn−1

2. Falls xm = yn trifft mindestens einer der folgenden Falle zu:

(a) Falls zk = xm dann ist Z auch lgT von Xm−1 und Y

(b) Falls zk = yn dann ist Z auch lgT von X und Yn−1

Die Idee hinter diesen Zusammenhangen entspricht wiederum jener von rekur-siven Algorithmen. Der Korrektheitsbeweis kann direkt gefuhrt werden.

Sei nun l[i, j], 0 ≤ i ≤ m, 0 ≤ j ≤ n die Lange der lgT von Xi und Yj . Danngilt:

l[i, j] =

0 falls i = 0 oder j = 0

l[i− 1, j − 1] + 1 falls xi = yj (Fall 1)

maxl[i− 1, j], l[i, j − 1] sonst (Fall 2)

Dies folgt unmittelbar aus obiger Beobachtung. Die Berechnung von l[m,n]durch direktes Einsetzen in die Rekursionsgleichung wurde (wie zu erwarten)zu exponentieller Laufzeit fuhren. ⇒ Anwenden von Dynamischem Program-mieren!

Beobachtung: Die Berechnung von l[i, j] benotigt nur Kenntnis von l[i − 1, j],l[i, j − 1] und l[i − 1, j − 1]. Wir speichern daher l[. . . ] in einer m × n–Matrixund berechnen diese zeilenweises “von unten nach oben”.

l[i,j]

unterlegter Bereich =

schattierter Bereich =bereits berechnet

wird verwendet

i := 0 to m j := 0 to n

3.3 Beispiele 29

Pseudo Code:

/* Initialisierung:for i := 0 to m do l[i, 0] := 0 odfor j := 1 to n do l[0, j] := 0 od/* Berechnen von l[. . . ]:for i := 1 to m do

for j := 1 to n doif xi = yj then

l[i, j] := l[i− 1, j − 1] + 1 / ∗ Fall 1else

l[i, j] := max(l[i− 1, j], l[i, j − 1]) / ∗ Fall 2fi

ododWRITELN(”maximale Lange:”, l[m,n])

Zeitanalyse: 2 FOR–Schleifen ⇒ O(m · n)Speicheranalyse: m× n–Matrix ⇒ O(m · n)

Diese Methode ist also wesentlich effizienter als die direkten Ansatze mit ex-ponentieller Laufzeit.

Bemerkung 1: Die Rekonstruktion der langsten gemeinsamen Teilfolge(n)kann leicht durch

”Ruckwartsdurchlaufen“ der Matrix l[i, j] ermittelt werden.

Ausgehend von l[m,n] verzweigt man entsprechend Fall 1 bzw. 2a oder 2b. ImFall 1 erhalt man dabei jeweils ein Zeichen der Folge. Da sich in allen Fallen ent-weder i oder j oder beide um 1 verkleinern, betragt die benotigte Zeit O(m+n).

Bemerkung 2: Wird nur die Lange der optimalen Teilfolge, nicht jedoch dieFolge selbst benotigt, so muß die Matrix l[i, j] nicht gespeichert werden → esgenugt, nur die letzten beiden Zeilen zu speichern!Durch ggf. Vertauschen von X und Y erhalt man daher einen Speicheraufwandvon O(minm,n).


Kapitel 4

Randomisierung

In diesem Abschnitt wird anhand einer konkreten Anwendung der Begriff ran-domisierter Datenstrukturen und der randomisierten Analyse erlautert. Ein wei-teres Beispiel fur einen randomisierten Algorithmus findet sich in Kapitel 6.3.

4.1 Randomisierte Suchbaume

Organisiertes Speichern von Daten fur raschen Zugriff ist ein Standardproblemin der Computerwissenschaft. Sind die Daten nach einem Kriterium totalorden-bar (etwa ≤), dann sind binarsortierte Suchbaume oft die geeignete Wahl.Werte x1, . . . , xn werden so in einem Binarbaum eingeordnet, daß der Baum insymmetrischer Reihenfolge (kurz SR: linker Teilbaum in SR, Wurzel, rechterTeilbaum in SR) sortiert ist.

4.1.1 Dynamische Datenverwaltung (Worterbuch-Problem)

Beim sog. Worterbuchproblem werden Daten nicht nur gesucht, sondern aucheingefugt bzw. entfernt. Dadurch kann der Baum jedoch entarten, sodaß einelogarithmische Tiefe nicht mehr garantiert werden kann! Um dies dennoch zuerreichen sind zusatzliche Maßnahmen notwendig. Je nach Restrukturierungs-technik unterscheidet man AVL–Baume, Bruderbaume, Rot–Schwarz–Baume,Splaybaume u.v.a.. Alle diese sind auf spezielle Art balanciert (nach Hohe, Teil-baumgroße etc.).

4.1.2 Ein neues Balancierungsschema - Prioritaten

Hier soll ein neues Balancierungsschema vorgestellt werden, die Balancierungnach Prioritaten1:

• Jeder Wert x erhalt Prioritat p(x)

• Der Baum bildet bezuglich der Prioritat eine Halde:Wurzel ≥ max rechter Sohn, linker Sohn


32 KAPITEL 4. RANDOMISIERUNG

Beobachtung: Besitzen alle Knoten verschiedene Werte und verschiedene Prio-ritaten, so ist der Baum eindeutig!

6

3 7

5

5

4 3

2 1

1

Bsp: 7 5 6 1 33 1 5 2 4

Beweis: Die Wurzel ergibt sich (eindeutig) als Wert mit großter Prioritat. Dierestliche Wertemenge zerfallt dann (eindeutig )in Werte < Wurzel (linker Teil-baum) und in Werte > Wurzel (rechter Teilbaum). Diese Teilbaume werdenjetzt rekursiv (eindeutig) gebaut.

Implementation der Worterbuchoperationen:

• Suchen: Wie bei “normalen” in SR sortierten Binarbaum.

• Einfugen: des Wertes x: x als Blatt anhangen, sodaß SR gewahrt (d.h.zuerst Position suchen). Im Allgemeinen wird aber die Haldenbedingungverletzt sein.⇒ Knoten nach oben rotieren! Eine Rotation erhalt SR, ord-net aber die Prioritaten zweier Knoten:

x

y x

y

A B

C A

B C

R.n.r.

R.n.l.

AxByC AxByC

z.B. im vorigen Beispiel: 46 einfugen.

6

3 7

1 5

4

3

1 4

5

6

4 7

3 5

1

4

3 6

1 5 7

5

4 3

2 1

6

R.n.r R.n.l

R.n.r

Fertig, wenn p(V)>p(x)oder wenn x=Wurzel,wie hier.

4.2 Randomisierte Analyse 33

• Entfernen: ist Umkehroperation: Nach unten rotieren, bis x =Blatt.Dieses wird

”abgehangt“. Die Entscheidung ob eine Rotation nach links

oder rechts erfolgen muß hangt ab von der Prioritat der Sohne von x ab:p(l) < p(r)⇔ Rotation nach links (Rnl), sonst Rotation nach rechts(Rnr).

4.2 Randomisierte Analyse

Die Laufzeitanalyse muß nur fur das Einfugen von Werten durchgefuhrt wer-den, da darin die Suche von Werten bereits enthalten ist, und das Entfernenvon Werten invers zum Einfugen erfolgt.

Laufzeit Einfugen:Suchzeit︸︷︷︸+#Rotationen︸︷︷︸Tiefe(x) r(x)

Im schlechtesten Fall konnen Tiefe(x) und r(x) beide Θ(n) sein. Jetzt nutzenwir aber aus, daß die Prioritaten frei wahlbar sind:

Idee: Einmal festgelegt, bestimmen die Prioritaten den Suchbaum fur die Wertex1, . . . , xn eindeutig. Viele dieser Baume sind ausreichend balanciert, nur wenigeentarten. ⇒ Zufallige Wahl der Prioritaten sollte guten Baum liefern! (Beispieleiner randomisierten Datenstruktur: Baum ist mit hoher Wahrscheinlich-keit gut.)

Vorgangsweise: Beim Einfugen eines neuen Wertes x wird p(x) zufallig

x

vp(x)

p(v) gewahlt, etwa als zufalliger binarer String gewisserLange. p(x) wird on–line und bitweise berechnet, undzwar nur wenn notwendig: Unterscheidet sich p(x) vonp(v) bereits im 1. Bit, dann fertig (genugt fur Vergleichp(x) < p(v)). Sonst berechne und vergleiche 2.Bit usw.

E[#notwendiger Bits] =∑i≥1

prob[i-tes Bit notwendig]

= 1 + 12 + 1

4 + 18 + · · · < 2

• Eventuell mussen auch zusatzliche Bits fur p(v) berechnet werden.⇒ Verdoppelt hochstens die Anzahl der zu berechnenden Zufallsbits.

• Muß rotiert werden, so kann sich dieser Prozeß fortsetzen.⇒ hochstens um Faktor r(x) mehr.Insgesamt: < 4(r(x) + 1) Zufallsbits pro Einfugen zu berechnen.

Wie groß sind nun r(x) und Tiefe(x) bei randomisierten Suchbaumen?


Satz: Sei x ein Knoten im randomisierten Suchbaum fur n Werte. Die Prio-ritaten p(xi) seien eine gleichverteilte, unabhangige Zufallsvariable. Dann gilt:

(a) E[r(x)] < 2

(b) E[Tiefe(x)] = Θ(log n)

Argumente fur (a) (kein formaler Beweis): E[p(x)] ist der Median aller Prio-ritaten. Da der Baum balanciert ist (folgt aus (b)) stehen ungefahr die Halfteder Werte im untersten Niveau. Dort wird aber x angehangt.⇒ Es wird extremwenig umstrukturiert, auch bei großen Datenmengen (unabhangig von der An-zahl n der gespeicherten Werte). Besonders vorteilhaft, da Rotationen

”teuer“

im Vergleich zum Suchaufwand.Aus (a) folgt, daß wenig umstrukturiert wird, und daß wenig “Zufalligkeit”

fur Prioritaten benotigt wird: im Erwartungswert weniger als 12 Bit pro neuemWert, unabhangig von n (Speicheraufwand linear).

Beweis von (b): Numeriere die Werte x1, . . . , xn so, daß p(x1) > p(x2) >· · · > p(xn). Da die Prioritaten unabhangig gleichverteilt sind, ist jede der n!Reihenfolgen gleich wahrscheinlich. D.h., x1, . . . , xn ist eine Zufalls–Reihenfolge.Der Baum wird nun durch Einfugen der Werte in genau dieser Reihenfolge er-zeugt. Es gilt damit:

1. Die Werte werden in zufalliger Reihenfolge eingefugt.

2. Der Baum ist unabhangig von der Einfuge–Reihenfolge (Eindeutigkeit!).

3. Der Baum wachst nur an den Blattern, es sind keine Rotationen notwendig(da Prioritaten stets kleiner werden).

Sei nun x ein beliebiger Wert. Betrachte, im fertigen Baum, den Suchpfad π vonder Wurzel zu x, seine Lange ist Tiefe(x). Laut Suchvorgang gehen von Wertenin π, die kleiner als x sind, rechte Kanten aus, und von allen anderen Werten inπ linke Kanten.

1

4

9

5

6

8

7 =x

Wir zahlen nur rechte Kanten (linke Kantenanalog).

Beobachtung: π bekommt eine neue rechte Kante genau dann, wenn (vor demEinfugen von x) ein Wert kleiner x eingefugt wird, der großer ist als alle vorihm eingefugten Werte kleiner x. (Zur Verdeutlichung: Dieser Wert wird an je-ner Stelle eingefugt, an die x zu diesem Zeitpunkt eingefugt worden ware!)

4.2 Randomisierte Analyse 35

Dies fuhrt auf folgendes Urnenmodell:Urne enthalt k Elemente (alle Werte kleiner x). Man zieht ohne Zurucklegen,bis Urne leer. Frage: Wie oft wird ein Element gewahlt, das großer ist als allebisher gezogenen?

Sei Ak der Erwartungswert fur diese Anzahl. Fur k ≥ 1 gilt folgende Rekur-sionsformel mit A0 = 0:

Ak =1

k

(k∑

i=1

(1 +Ai−1︸︷︷︸))

i-großtes Element als erstes gezogen⇒ i− 1 großere bleiben in Urne

=1

k

[k +

k−1∑i=1

Ai

]= 1 +

1

k

k−1∑i=1

Ai

Losung: Ak =k∑

i=1

1i [k-te harmonische Zahl, Ak = Θ(log k)]

Insgesamt ergibt sich der Erwartungswert Θ(log k) fur rechte Kanten von π(und damit von Θ(log(n − k)) fur linke Kanten). Es folgt im ErwartungswertTiefe(x) = Θ(log n), da k = Θ(n).

Aus den beiden Eigenschaften (a) und (b) ergibt sich damit:

Satz: Die Worterbuchoperationen konnen mit einem randomisierten Suchbaummit hoher Wahrscheinlichkeit in je O(log n) Zeit durchgefuhrt werden.


Teil II

Geometrische Algorithmen

Kapitel 5

Schnitt vonLiniensegmenten

5.1 Problemdefinition

Die rechnerische Losung geometrischer Probleme liefert ein nahezu ideales Ubungs-gebiet fur den Entwurf von Algorithmen:

• Algorithmische Methoden (Beispiel Dynamisches Programmieren bei Polygon–Triangulierungen)

• Geeignete Datenstrukturen (im Folgenden verwendet)

• Geometrie–spezifische Methoden (etwa plane-sweep Technik, im Folgen-den verwendet)

Problem:Gegeben n Liniensegmente in der Ebene, finde alle ihre Schnittpunkte.

Anwendung:

n2

a) c)b)

a) Hidden–line Algorithmus

b) Layout von Schaltkreisen, VLSI (Schritt–Detektor testet Heuristik)

• Implizit in geometrischen Algorithmen

40 KAPITEL 5. SCHNITT VON LINIENSEGMENTEN

5.2 Naiver Algorithmus

Beobachtungen:

• Grundoperation: Segment–Schnitt, leicht in konstanter Zeit durchfuhrbar.

• Es kann Θ(n2) Schnittpunkte geben (siehe c)). D.h. im schlechtesten Fallbenotigt jedes Verfahren quadratische Laufzeit bereits zum Berichten derSchnitte! Laufzeit O(n2) ist aber leicht zu erreichen. (O(1) pro Segment–Paar)

• Laufzeit sollte daher von der Anzahl k der Schnittpunkte abhangig sein,d.h. T (n, k), soll output–sensitiv sein.

5.3 Plane-Sweep Algorithmus

Der folgende Algorithmus beruht auf einer einfachen Beobachtung: Wenn sichzwei Segmente schneiden, so uberlappen sich ihre X–Intervalle.

Umkehrung i.A.falsch

⇒ Idee: Durchlaufen”aller“ x–Werte mit einer Vertikalen L. Zu jedem Zeitpunkt

werden nur die gerade von L getroffenen Segmente auf Schnitt gepruft.→ Plane–Sweep Technik 1 (vgl. Scan–line Prinzip, Kapitel 1.2.1)

L

Genauer:(1) Jede Position von L gibt eine Y-Sortierung der geschnittenenSegmente (uber Schnittpunkte mit L, oberer, unterer Nachbar).(2) Schneiden sich zwei Segmente, so sind sie

”vorher“ (bezuglich

X-Sortierung) auf L (bezuglich Y-Sortierung) benachbart.⇒ Algorithmus: Aufrechterhalten der Y-Sortierung auf L, PrufenY-benachbarter Segmente auf Schnitt.Der Plane–Sweep ist ereignisgesteuert, wobei ein Ereignis eineAnderung in der Y-Sortierung ist.

Es gibt drei verschiedene Arten von Ereignissen:


5.3 Plane-Sweep Algorithmus 41

Linker Endpunkt: Rechter Endpunkt: Schnittpunkt:Segment Segment Benachbarteeinfugen entfernen Segmente switchen

Beispiel:

1

2

4

3

Schnittpunkte konnen evt. mehrfach erkannt werden, und werden auch nichtunbedingt X–sortiert erkannt.

5.3.1 Implementations-Details

X: x–Koordinaten der bislang bekannten, aber von L noch nicht erreichten Er-eignisse (Anfangs- und Endpunkte, bereits bekannte Schnittpunkte). Einfugen,x–Minimum entfernen ⇒ Warteschlangenproblem, Datenstruktur etwa Halde.Y: (Sortierung auf L) y–sortierte Menge der Segmente, die von L getroffen wer-den. Einfugen, Entfernen, Switchen (Schnittpunkt) ⇒ Worterbuchproblem, alsDatenstruktur etwa (2–4)–Baum2.

Algorithmus Segment–Schnitt: X = 0, Y = 0Fuge x–Koordinate der Anfangs– und Endpunkte des Segments in X einwhile X = ∅ do

1. Bestimme Minimum m von X und entferne m aus X.

2. IF m linker Endpunkt THEN fuge sein Segment in Y einELSE if m rechter Endpunkt THEN entferne sein Segment aus YELSE (m Schnittpunkt) vertausche die betroffenen Segmente in Y

2Information ist in den Blattern gespeichert; der Baum ist sortiert!


3. FOR alle neuen Nachbar–Paare in Y DOIF Schnitt p = ∅ existiert und p rechts von L ist THENberichte p und fuge x–Koordinate von p in X ein

Feinheiten: Beim Einordnen eines Segmentes in den Suchbaum Y werden y–Koordinaten der Segmentschnitte mit L verglichen. Diese werden fur die mo-mentane Position von L on-line wahrend des Suchvorgangs berechnet.

Nachbarn finden in Y geht leichter, wenn Suchbaum in sortierter Reihenfolge

”verkettet“ ist.

Analyse: n Segmente, k Segmentschnitte, 0 ≤ k ≤(n2

)= O(n2)

In X: Pro Segment werden 2 Ereignisse, pro Schnitt 1 Ereignis eingefugt. Jedesdieser Ereignisse wird wieder entfernt.⇒ O((n+ k) log(n+ k)) = O((n+ k) log(n)) Zeit und O(n+ k) Speicher

In Y: Jedes Segment wird genau einmal eingefugt bzw. entfernt. Segmentpaarewerden pro Schnitt vertauscht.⇒ O(n logn+k) Zeit, O(n) Speicher, O(1) pro Switch, wenn Schnittpunkte mitihren Segmenten assoziiert werden.

Daher fur X und Y gesamt O((n+ k) log n) Zeit.

Beachte: Mehrfach erkannte Schnitte storen die Analyse nicht da sie zu an-deren Ereignissen (z.B. neue Nachbar–Paare) aufgerechnet werden konnen.

Satz Die k Schnittpunkte von n Liniensegmenten in der Ebene konnen inO((n+ k) log(n)) Zeit und O(n+ k) Speicher gefunden werden.

Bemerkungen:

• Um linearen Speicher zu erreichen kann man in der X-Datenstruktur furjedes Segment nur den ersten noch nicht abgearbeiteten (d.h. von derScanline uberstrichenen) Schnittpunkt speichern. Die Zeit bleibt dabeiunverandert, der Speicherbedarf sinkt jedoch auf O(n).

• Laufzeit kann auf O(n logn + k), Speicher wie oben erwahnt auf O(n)reduziert werden; Beides ist auch gleichzeitig moglich [Balaban, 1995]!

• Programm funktioniert als Schnitt–Detektor in optimaler Zeit O(n log n)bzw. optimalem Speicher O(n). (Setze k = 0 bzw. k = 1)Es geht jedoch auch einfacher: Alle Ereignisse bis auf den ersten Schnittsind vorab bekannt. Wird dieser gefunden, dann Abbruch. ⇒ X als (sor-tiertes) lineares Feld, keine Warteschlange, da statisch

• Schnitt–Detektor fur z.B. Kreisscheiben ahnlich aufgebaut:

5.3 Plane-Sweep Algorithmus 43

L

Jedoch nur als Schnitt–Detektor geeignet, da nicht alle Schnitte berichtetwerden! Beobachtung: Wenn Schnitte existieren, dann gibt es zwei schnei-dende Scheiben, deren horizontale Durchmesser irgendwann auf L benach-bart sind. ⇒ lineares Feld mit rechtem, linkem Endpunkt als Ereignisse(2n x–Werte). Y speichert pro Scheibe den y–Wert des Mittelpunktes.Neue Nachbarn direkt auf Schnitt prufen in O(1).Schnitt–Erkennung zwischen Kreisscheiben hat viele Anwendungen:

– Einflußbereiche (Okonomie), so sind Verbreitungsgebiete (Biologie)oft kreisformig modelliert.

– Bewegungsplanung: Kritische Punkte mit Toleranzkreis umgeben.

– Numerische Ungenauigkeiten, Meßfehler oft in kreisformiger Umge-bung des exakten Wertes.

Der einfache O(n log n)–Algorithmus ist dabei der naiven Θ(n2)–Methodeweit uberlegen.


Kapitel 6

Konvexe Hullen


Sei S = p1, ..., pn eine Punktemenge in der Ebene. Die Konvexe Hulle vonS, kurz KH(S), ist das kleinste konvexe Polygon, das S enthalt.KH(S) =

∩P⊃S

P konvex, sog.”Gummiband–Definition“.

Die Berechnung der konvexen Hulle ist ein zentrales Thema im Bereich Geome-trische Algorithmen. (KH ist eine geometrische Datenstruktur)!

6.1.1 Einige direkte Anwendungen und Beobachtungen

• Weite eines Polygons (dies ist der minimale Abstand paralleler Tangentenan das Polygon)

Weite

?

Weite <= Tunnel => geht durch

Robotik

46 KAPITEL 6. KONVEXE HULLEN

• Durchmesser einer Punktemenge (maximaler Abstand zweier Punkte ausS), d(S) = maxdistanz(p, q) | p, q ∈ S

p

p

dist(p,q)

Sprechweise: p liegt auf KH(S), wenn p am Rand, also nicht im Innerenvon KH(S) liegt. p heißt dann auch extrem (bzgl. S).Anwendung des Durchmessers z.B. bei Clusterverfahren: der Durchmesserist ein Maß fur die Große und damit Qualitat eines Clusters.

• Separationsgerade

Eine Separationsgerade existiert genau dann, wenn sichKH( ) undKH( )nicht schneiden. Die Mengen sind dann linear separierbar. Direkte Anwen-dung z.B. in der Datenklassifikation.

• Viele weitere geometrische Algorithmen bauen auf KH-Algorithmen auf.

Die Definition einer konvexen Hulle liefert folgenden Algorithmus:Finde kleinste Teilmenge R ⊂ S mit KH(R) = KH(S). Der direkte Zugangbenotigt jedoch Ω(2n) Zeit. Man sucht daher nach Eigenschaften von KH(S).

Beobachtung: Sei p, q, r, s ∈ S. Wenn s ∈ ∆(p, q, r), dann s nicht auf KH(S).

6.2 Erste optimale Losung (Graham-Scan) 47

p

q

r

s

⇒ Naiver Algorithmus:(n3

)= Θ(n3) Dreiecke, pro ∆ n − 3 Inklusionstests

⇒ Θ(n4) Zeit gesamt.

Obwohl schnelle KH-Algorithmen nicht offensichtlich sind, gibt es eine Vielzahlvon optimalen, O(n logn), Losungen. Etwa fuhrt das Entwurfsprinzip D&C aufdiese Laufzeit (siehe LV Geometrische Algorithmen).

6.2 Erste optimale Losung (Graham-Scan)

Eine Abwandlung der Plane–Sweep Technik1 liefert erste optimale Losung2

[Graham, 1972]:

Idee: KH reflektiert eine zyklische Ordnung der extremen Punkte ⇒ zyklischsortieren, nicht extreme Punkte loschen.

1Vergleiche auch Kapitel 12Hinweis: Zu diesem Kapitel gibt es auf der Lehrveranstaltungshomepage zur Veranschau-

lichung einen animierten Algorithmus.


p3

p2

p1

pn

Fur alle p ∈ S, seien p = (r, ϕ) die Polarkoordinaten von p bezuglich des unter-sten Punktes p1; dieser ist stets auf KH(S).

Sortieren von S\p1 nach Polarwinkeln ⇒ p2, p3, ..., pn und einmal durch-laufen aller Punkte in dieser Reihenfolge, wobei Punkte mit Innenwinkel > πentfernt werden.

Datenstruktur: Stapel ST der bisherigen KH-Punkte.

Operationen: PUSH, POP wie ublichTOP oberstes ElementTOP− zweit–oberstes Element

Pseudo Code:

GRAHAM-KHSortiere Punkte bezuglich Polarwinkel um p1PUSH(p1, p2, p3)for i = 4 to n do

while ^(TOP−, TOP, pi) > π do /* Teste Innenwinkel der letzten drei Punkte */POP

odPUSH(pi) p2, pn stets auf KH(S)!

Laufzeitanalyse: Potentialmethode:Potential = Anzahl Elemente am Stapel ST = σ(ST )σ(ST ) = 3 am AnfangPro “for” wird σ(ST ) um ≤ 1 erhohtPro “while” wird σ(ST ) um 1 erniedrigtσ(ST ) ≥ 3 zum Schluß⇒≤ n− 3 while–Durchlaufe ⇒ O(n) ZeitUmrechnen in Polarkoordinaten: O(n)Sortieren nach Polarwinkeln: O(n log n)

Satz Die konvexe Hulle von n Punkten in der Ebene kann in O(n log n) Zeitund O(n) Speicher berechnet werden.

Der beschriebene Algorithmus verallgemeinert sich nicht in einfacher Weise

6.3 Iteratives Einfugen 49

auf die 3D–Situation, im Gegensatz zu D&C und zum folgenden Einfuge–Algorithmus.

6.3 Iteratives Einfugen

Der folgende Algorithmus baut die KH Schritt fur Schritt auf, indem die Punk-te in zufalliger Reihenfolge zur bereits bestehenden konvexen Hulle 3 hin-zugefugt werden. Die Analyse wird Techniken verwenden, wie sie bereits imKapitel 4 uber randomisierte Algorithmen vorgestellt wurden.

Start: Dreieck p1p2p3 (bzw. Tetraeder p1p2p3p4 im 3D–Fall)Generischer Schritt: KH(R ∪ p) aus KH(R) erzeugen (Einfugen von p)

P

P

Beim Hinzufugen eines Punktes gibt es zwei Moglichkeiten: Ist p ∈ KH(R),dann wird p geloscht. Sonst werden die von p aus sichtbaren Kanten von KH(R)geloscht, und neue Tangenten gelegt.

Dabei kommen im i–ten Schritt ≤ 2 neue Kanten dazu, ki ≥ 0 alte Kanten

werden geloscht ⇒n∑

i=4

ki ≤ 2(n− 3) + 3⇒ O(n) Zeit!

Es wurde jedoch ein”Orakel“ unterstellt, das p ∈ KH(R) entscheidet und,

wenn nein, eine sichtbare Kante (Startkante) liefert. Das Orakel kann auf fol-gende einfache Weise implementiert werden:

Zu Beginn wird ein innerer Punkt c von KHp1, p2, p3 gewahlt, etwa derSchwerpunkt: c = 1

3 (p1 + p2 + p3), c ∈ KH(R), ∀R ⊂ S. Fur jeden noch nichteingefugten Punkt q, q ∈ S\R, wird die Schnittkante eq von KH(R) mit demSegment cq gespeichert (oder ein entsprechender Verweis, daß eq nicht existiert)⇒ O(n) Zusatzspeicher.



p

p

p

q’

q

e

e

e

KH(R )

KH(R )

c

1

2

3q’

q

q

1

2

1

1

2

Wenn q an der Reihe zum Einfugen ist, dann ist eq Zeuge dafur, daß q außer-halb der aktuellen Hulle liegt. Gleichzeitig ist eq von q aus sichtbar und so-mit eine Startkante ⇒ O(1) Zeit fur Orakel–Antwort! Jedoch muß die Zeugen–Information upgedatet werden!

Zu Beginn bekommt jeder Punkt einen “Anfangszeugen”: O(n) Zeit furSchnittbestimmung, ∆(p1, p2, p3) ∩ cq, ∀q ∈ S\p1, p2, p3Wann andert sich die Zeugeninformation? Beim Loschen von Kanten!

pKH(R)

c

q

eq

Wird p eingefugt, dann muß eq neu bestimmt werden. Zwei neue Kanten ⇒Neubestimmung von eq in O(1) Zeit pro q ⇒ Insgesamt Θ(k) Aufwand, wennk Punkte ihren Zeugen verloren haben. (Hinweis: Die k Punkte waren in Listengespeichert, die dem alten Zeugen zugeordnet waren.)k kann (zu) groß sein (z.B. wenn die Punkte sortiert betrachtet werden), aller-dings nicht, wenn die Punkte in zufalliger Reihenfolge eingefugt werden, wie diefolgende Analyse beweist.

6.3.1 Randomisierte Analyse

Gesucht ist der Erwartungswert E[Anzahl Zeugen pro Punkt q], d.h., wievieleZeugen es fur den Punkt q wahrend des Algorithmus insgesamt gab.Ein fixer Punkt q, sei an i–ter Stelle in zufalliger Reihenfolge eingefugt worden.Betrachte Schritt j < i, bei dem ein Punkt p als j–ter Punkt eingefugt wird(also noch vor q, sonst keine Beeinflussung).Sei eq(j) der Zeuge fur q nach Einfugen von p, und eq(j − 1) jener davor. Wir

6.3 Iteratives Einfugen 51

suchen prob[eq(j) = eq(j − 1)]︸︷︷︸Tritt genau dann ein, wenn p einer der Endpunkte von eq(j) ist !

.

Zeitliche Reihenfolge veranschaulicht:

1 j i n

p q

Fur einen festen Punkt q war eine fixe Kante eq(j − 1) der bisherigen Hulle derZeuge. Diese unterscheidet sich vom Zeugen eq(j) genau dann, wenn p einer derEndpunkte von eq(j) ist, da nur dann eq(j) neu entstanden sein kann! ⇒ 2 vonj Punkten gunstig.

q

p

e (j)

e (j-1)q

q

⇒ prob = 2j , da der zuletzt eingefugte Punkt p jeder der j Punkte mit gleicher

Wahrscheinlichkeit ist (p zufallig gewahlt).

E[# Zeugen fur q] =

i−1∑j=4

prob[eq(j) = eq(j − 1)] =

=i−1∑j=4

2

j< 2

i−1∑j=1

1

j= 2Hi−1

= Θ(log i) = O(log n)

Hi...i–te harmonische Zahl

Fur einen fix gewahlten Punkt q ∈ S andert sich sein Zeuge im erwartetenFall also O(log n) mal ⇒ Gesamtaufwand O(n log n) zur Verwaltung der Zeu-gen aller n Punkte.

Satz Die konvexe Hulle von n Punkten in der Ebene kann durch randomisiertesEinfugen in O(n logn) erwarteter Zeit und O(n) Speicher berechnet werden.

Bemerkungen:

• Algorithmus ist nicht on–line. Man muß alle Punkte zu Beginn kennen.

• Einfugen kann pro Punkt O(n) Zeit brauchen. Wahrscheinlichkeit dafurist aber gering.

• Erwartete Laufzeit ist unabhangig von der Lage von S (keine speziellePunkteverteilung).


• Ω(n log n) ist untere Zeitschranke fur KH–Problem, da implizit sortiertwird (Ubung!).

• Der Einfugealgorithmus laßt sich fur hohere Dimensionen verallgemeinern.

• Der Einfugealgorithmus kann auch in deterministischer Zeit O(n log n)ausgefuhrt werden. (siehe Lehrveranstaltung Geometrische Algorithmen,Kapitel 2 und 3)

Kapitel 7

Optimale Triangulierungvon Polygonen

Beim Entwurf von Algorithmen spielen geometrische Fragestellungen eine zu-nehmend starkere Rolle. Motivationen kommen u.a. aus Bereichen wie Compu-tergrafik, Numerik, Optimierung und CAD. Ein vieluntersuchter Problemkreishat das Zerlegen von geometrischen Objekten in “einfache Teile” zum Gegen-stand. Wir betrachten hier folgenden Spezialfall:

simples Polygon: Von n ≥ 3 nichtkreuzenden Geradenstucken begrenzte, zu-sammenhangende Teilmenge der Ebene. Beispiel:

Ein konvexes Polygon P besitzt keine einspringenden Ecken. Formal: ∀x, y ∈P : xy ⊂ P . Beispiel:

y

x

Ecken, Kanten, Diagonalen.

Ein konvexes Polygon enthaeltalle seine Diagonalen.

7.1 Triangulierung von konvexen Polygonen

Eine Triangulierung eines (konvexen) Polygons P ist eine Menge von nicht-kreuzenden (inneren) Diagonalen, die P vollstandig in Dreiecke zerlegt.

54KAPITEL 7. OPTIMALE TRIANGULIERUNG VON

POLYGONEN

Ist das Polygon P n-seitig so besitzt jede (!) Triangulierung vonP genau n − 3 Diagonalen und n − 2 Dreiecke (Ubung: Beweisdurch Induktion uber n!).

Obiges Bild gibt eine Darstellung einer Triangulierung fur ein konvexes Po-lygon wieder. Fur simple (nicht notwendigerweise konvexe) Polygone sieht diesahnlich aus, jedoch durfen nur Diagonalen verwendet werden, die vollstandigim Inneren des Polygons liegen. Fur beliebige Punktmengen S in der Ebene isteine Triangulierung wie folgt definiert: Das durch die konvexe Hulle von S be-schrankte Gebiet wird durch von S×S aufgespannte Segmente vollstandig aberdisjunkt in Dreiecke zerlegt (d.h. alle im Inneren der Punktmenge entstehendenFlachen mussen Dreiecke sein und durfen sich gegenseitig nicht uberlappen).

Alternativ aber aquivalent dazu (vergleiche Kapitel 8) ist auch folgende De-finition: Eine Triangulierung einer Punktmenge S ist ein maximaler, planarer,geradliniger Graph auf S.

Wegen seiner grundlegenden Struktur spielt der Be-griff der Triangulierung von Punkten in vielen Gebie-ten eine zentrale Rolle, siehe z.B. bei der Visualisie-rung von Gelandeformen oder dreidimensionalen Ob-jekten, geometrischen Algorithmen, numerischen Simu-lationen und Optimierungen ... (weitere Informationendazu bietet z.B. die Lehrveranstaltung ’GeometrischeAlgorithmen’).

7.1.1 Optimale Triangulierung

Die Optimale Triangulierung (englisch. Minimum Weight Triangulati-on, kurz MWT) ist unter allen moglichen Triangulierungen eines Polygons /einer Punktmenge jene, die die minimale Gesamtlange aller Diagonalenergibt. Anwendung finden solche Triangulierungen z.B. in der Optimierung von3D-Oberflachen–Interpolationen.

7.1 Triangulierung von konvexen Polygonen 55

Kurze ubersicht uber den Komplexitats–Status verschiedener Triangulierungs-probleme:

Objekt→ konvexes beliebiges allgemeineTriangulierung↓ Polygon Polygon Punktmenge

beliebige O(n),trivial O(n3) leicht O(n log n)O(n) 1990 Ω(n log n)

optimale O(n3) O(n3) NP-vollstandig (2006)

Algorithmen fur beliebige Triangulierung auf Punktemengen: Einfuge–Algorithmus,Scan–Line–Methode, Delaunay–Triangulierung,. . .

Fur die Berechnung der optimalen Triangulierung von all-gemeinen Punktemengen ist der Komplexitats–Status erstseit 2006 geklart [Rote/Mulzer, SCG 2006]: Unter der An-nahme N = NP (siehe Kapitel 11) gibt es dafur keinenpolynomiellen Algorithmus (Laufzeit O(nk), k unabhangigvon n).

Obwohl das Problem der optimalen Triangulierung fur allgemeine Punkt-mengen mit zu den altesten Problemen der Informatik zahlt, war es lange un-gelost. Einige Grunde dafur sind:

• Fast keine Eigenschaften bekannt. Erst seit 1998 wurden hier jedoch in-teressante Fortschritte erzielt die schlußendlich zur Losung fuhrten.

• Es gibt Ω(2n) verschiedene Triangulierungen (genauere Schranken (der-zeit: Ω(2.631n)) sind Gegenstand aktueller Forschung).

7.1.2 Anzahl Triangulierungen eines konvexen Polygons

Wir zahlen zuerst die Anzahl von Triangulierungen fur den Fall eines konvexenn-Ecks (einfachster Spezialfall: Punktmenge in konvexer Lage) 1

Fur ein konvexes Polygon P kann die Triangulierung von P mit einemBinarbaum assoziiert werden:

d1

d2

We

Wurzel = Kante e von P .e liefert eindeutiges Dreieck e d1 d2, das P in 2 konvexePolygone P1, P2 teilt. Ist d1 (d2) eine Diagonale von P , soist d1 (d2) die Wurzel des Binarbaumes fur P1 (P2). Sonstist d1 (d2) eine Kante von P und ein Blatt im Binarbaumfur P .

Der so konstruierte Baum hat n− 1 Blatter (alle Kanten bis auf Wurzel-Kante)und n − 2 innere Knoten (Wurzel (1) plus Diagonalen (n − 3)). Verschiedene



POLYGONEN

Triangulierungen ergeben dabei verschiedene Binarbaume (bei fixer Wurzelkan-te) ⇒ #Baume ≥ #Triangulierungen.

Betrachten wir nun den inversen Prozess: Aus einem Binarbaum (vollstandig)mit n−1 Blattern wird eine Triangulierung eines konvexen n–Ecks erzeugt (vonunten nach oben abarbeiten: Durch Zusammenfassen zweier Blatter (Diagona-len) erhalt man einen inneren Knoten, der eine weitere Diagonale und damit diedrei Kanten des entsprechenden Dreiecks festlegt.).

1 2 3

4 5

n-1=5

e

Kanten gegen Uhrzeiger

12

3

4 5

6-Eck

Blätter v.l.n.r

Verschiedene Binarbaume ergeben dabei verschiedene Triangulierungen (bei fi-xer Wurzelkante). ⇒ #Triangulierungen ≥ #Baume.

Zusammen ergibt sich damit daß die Anzahl von Triangulierungen eines kon-vexen n-Ecks genau gleich der Anzahl von vollstandigen Binarbaumen mit n−1Blattern ist.

Sei β(m) die Anzahl der verschiedenen vollstandigen Binarbaume mit mBlattern.

k+1k

Wurzel

1 m

Betrachtet man alle moglichen Aufteilungen in linke und rechte Teilbaume, soerhalt man folgende, rekursive Formel:

β(m) =m−1∑k=1

β(k)β(m− k), β(1) = 1

Dies entspricht aber gerade den bereits bekannten Catalan–Zahlen2 mit derLosung: β(m) = 1

m

(2m−2m−1

)= Ω(2m).

Eine einfache untere Schranke erhalt man, wenn man die Summe nur durchihren ersten (k = 1) und letzten (k = m− 1) Wert abschatzt:

β(m) > β(1)β(m− 1) + β(m− 1)β(1) = 2β(m− 1) > · · · > 2m−1β(1) = Ω(2m)

2Vergleiche die Bemerkungen uber Catalan–Zahlen in Kapitel 3.3.1

7.2 Algorithmus zur optimalen Triangulierung 57

7.2 Algorithmus zur optimalen Triangulierung

Aufgrund der Konvexitat von P laßt sich uber die optimale Triangulierung,T (P ), etwas aussagen:

p1p 2

Sei ∆ ein Dreieck in T (P ). Dann gilt T (P ) = T (P1) ∪ ∆ ∪ T (P2) (ware etwadas konvexe Teilpolygon P1 in T (P ) anders trianguliert, z.B. mittels T (P1),so konnte man T (P1) durch T (P1) ersetzen und die Gesamtlange von T (P )reduzieren – Optimalitat von Teilproblemen!)Idee: Zuruckfuhrung des Problems auf kleinere Polygone! 3

Algorithmus:

• Wahle beliebige Kante e von P . (e hat eindeutiges Dreieck ∆ in T (P ).)

• Da ∆ unbekannt: Fur alle n−2 Dreiecke mit Basis e, lose das Problem furdie zwei induzierten Teilpolygone rekursiv, und nimm die beste Losung.

Beispiel: 7-Eck

e

i-Eck j-Eck

A:

3

6

5

4 4

5 3

6

5 Moeglichkeiten

/

/

mehrfachbetrachtet!

A

B

A:

B:

&

&

fach betrachtet.

identische Teil-stuecke werden mehr-



POLYGONEN

Eine Anwendung der einfachen Idee als Rekursion ist nicht sinnvoll:

T (n) =n−1∑i=2

(O(1) + T (i) + T (n− i+ 1)), wobei

n−1∑i=2

. . . Alle Moglichkeiten fur ∆

O(1). . . Aufwand zum TeilenT (i). . . Aufwand fur linkes TeilgebietT (n− i+ 1). . . Aufwand fur rechtes Teilgebiet

T (n) = O(n) + 2n−1∑i=2

T (i)

> 2(T (n− 1)) = 2n−1T (1) = Ω(2n)

D.h. es ist zumindest exponentielle Laufzeit erforderlich.⇒ Besser: DynamischesProgrammieren.

7.2.1 Dynamisches Programmieren

Wiederum findet hier die im Kapitel 3 besprochene Methode des dynamischenProgrammierens als Spezialfall von Divide and Conquer Anwendung.

n-1n-2

n

Da viele Teilprobleme wiederholt auftreten, aber nur einmal gelost werden mussen,ist dynamisches Programmieren effizient.

Indexrechnung fur dynamisches Programmieren:

vi

i+1v

vk

vj

v1, . . . , vn Ecken des Polygons PPij = (vi, vi+1, . . . , vj) Teilpolygon von PLij ”

Lange“(=Summe Kantenlangen) von T (Pij) (opt. Tri-angulierung)u(i, j, k) Umfang des Dreiecks vivjvk

Es gilt Lij = mini<k<j

u(i, j, k) + Lik + Lkj mit Li,i+1 = 0

Wir berechnen daher die Werte Lij nach zunehmender Differenz zwischen i undj (dabei ist j− i+1 die Anzahl betrachteter Punkte), beginnend mit Li,i+1 = 0

7.2 Algorithmus zur optimalen Triangulierung 59

2

j=1

n i=1

2

n

x

0 0 00

x

i

j

Matrix L[1..n, 1..n]Weiters Matrix S gleicher Dimension, fur Tei-lungsindex S[i, j] ∼= Spitze uber Basis vivj

Pseudo Code:

for i := 1 to n− 1 do L[i, i+ 1] = 0 odfor l := 2 to n− 1 do

for i := 1 to n− l doj := i+ lL[i, j] =∞for k := i+ 1 to j − 1 do

x := L[i, k] + L[k, j] + u(i, j, k)if x < L[i, j] then

L[i, j] := xS[i, j] := k

Analyse:Laufzeit Θ(n3), wesentlich besser als 2n

Speicher Θ(n2)

T (P ) kann aus S in O(n) Zeit rekonstruiert werden. Beginnend mit ∆1 =(1, n, S[1, n]) werden der Reihe nach die Dreiecke der Triangulierung aufgebaut.Dabei ermittelt man aus jeweils zwei Punkten a und b der Basis eines Dreieckesdessen dritten Punkt als S[a, b]:

S[1,k]

1n

S[k,n]

usw.

k=S[1,n]

S[1,S[1,k]]

S[S[1,n],S[k,n]]


POLYGONEN

Durch u(i, j, k) wurden zuviel Kanten gezahlt:

• Jede Diagonale von P zweifach

• Jede Kante von P einfach

⇒ L1n =∑

Kanten von P︸︷︷︸+2∑

Diagonalen︸︷︷︸U(P ) prod.Triang.–Lange

Da der Umfang U(P ) unabhangig von der berechneten Triangulierung ist, istL1n minimal genau dann wenn

∑Diagonalen minimal wird. Daher produziert

der Algorithmus tatsachlich die optimale Triangulierung T (P ).

Satz: Die optimale Triangulierung eines konvexen Polygons kann in O(n3) Zeitund O(n2) Speicher berechnet werden.

7.2.2 Simple Polygone

Auch fur ein simples (nicht notwendigerweise konvexes) Polygon kann die op-timale Triangulierung in O(n3) Zeit und O(n2) Speicher berechnet werden.Idee: Wird das Teilpolygon Pij betrachtet, so muß zuerst (in O(n) Zeit) ge-testet werden, ob die Kante vivj ausserhalb des Polyons liegt oder zu einerSelbstuberschneidung fuhrt. Falls dies der Fall ist wird L[i, j] = ∞ gesetzt. Inallen anderen Fallen erfolgt die Berechnung wie im konvexen Fall. Durch die∞-Gewichtung selbstuberschneidender Teile werden nur gultige Triangulierungenuntersucht.

Teil III

Graphen Algorithmen

Kapitel 8

EinfacheGraphen–Algorithmen

8.1 Grundbegriffe der Graphentheorie

Graph: Ein gerichteter Graph ist ein Paar (V,E), wobei V eine endliche Mengeund E eine binare Relation auf V ist (E ⊆ V × V )V . . . Knotenmenge, n =| V | . . . Anzahl von KnotenE . . . (gerichtete) Kantenmenge, m =| E | . . . Anzahl (gerichteter) KantenDiese Definition legt einen gerichteten Graphen fest.

Beispiel:V = 1, 2, 3, 4, 5E = (1, 2), (2, 3), (3, 2), (4, 5), (4, 4)

1 2 4 5

3

Weitere wichtige Definitionen:

• Ein ungerichteter Graph G = (V,E) ist ein gerichteter Graph, wobei Esymmetrisch ist, d.h.: (v, w) ∈ E ⇔ (w, v) ∈ E, ∀v, w ∈ V

• Ein gewichteter Graph ist ein Tripel G = (V,E, g), wobei g : E → Z+0

jeder Kante ein Gewicht zuweist.

• EinPfad von v nach w, v, w ∈ V , ist eine Folge von Knoten v = v0, v1, v2, . . . vk =w, vi ∈ V ; i = 0 . . . k, wobei (vi, vi+1) ∈ E, i = 0 . . . k − 1, gilt. Ein Pfadist einfach, wenn vi = vj , 0 ≤ i, j ≤ k gilt.

• Ein Kreis ist ein Pfad von v nach v. Ist dieser Pfad mit Ausnahme v0 = vkeinfach, so ist der Kreis einfach.

• Die Lange eines Pfades (Kreises) ist die Anzahl seiner Kanten (k) bzw.die Summe der Kantengewichte bei gewichteten Graphen.

64 KAPITEL 8. EINFACHE GRAPHEN–ALGORITHMEN

• Ein Graph heißt azyklisch, wenn er keinen nichttrivialen einfachen Kreisenthalt (gerichtet: k ≥ 2, ungerichtet: k ≥ 3)

• Ein Graph heißt zusammenhangend, wenn es fur jedes Paar (v, w), v, w ∈V einen Pfad in V gibt.

• Ein azyklischer, ungerichteter Graph heißt Wald. Ein azyklischer, unge-richteter, zusammenhangender Graph heißt Baum. Fur einen Baum giltstets: m = n − 1 (Beweis: Ubung, analoge Baum/Wald Definitionen sindauch fur gerichtete Graphen moglich, jedoch muß hier die Rolle der Wurzelexplizit festgelegt werden.)

• Die In–Valenz (Out–Valenz) eines Knotens v ist die Anzahl von Kan-ten, die in v enden (beginnen):

In–Valenz(v) :=| w | (w, v) ∈ EOut–Valenz(v) :=| w | (v, w) ∈ E

(fur ungerichtete Graphen gilt naturlich In–Valenz = Out–Valenz und manspricht hier nur von Valenz oder Grad eines Knotens)

• Fur ungerichtete Graphen gilt:

Grad(v) = 0→ v ist isolierter KnotenGrad(v) = 1→ v ist Endknoten (Blatt)

Der Graph heißt regular vom Grad r, wenn jeder Knoten des Graphenden Grad r besitzt

Beispiel: Regular vom Grad 3:

1 2

3 4

• Ein vollstandiger Graph besitzt alle moglichen(n2

)Kanten (= regular

vom Grad n− 1)

• Ein leerer Graph besitzt keine Kanten (regular von Grad 0)

• Der Abstand eines Knotens w von einem Knoten v ist die Lange deskurzesten Pfades von v nach w bzw. ∞, wenn es keinen solchen Pfadgibt.

• EinTeilgraphG′ vonG ist ein Graph mitG′ = (V ′, E′), G = (V,E), V ′ ⊆V,E′ ⊆ E wobei ∀(v′, w′) ∈ E′ gilt v′ ∈ V ′, w′ ∈ V ′

8.2 Speicherung von Graphen 65

8.2 Speicherung von Graphen

Graphen sind eine vielseitige Datenstruktur und daher sind Algorithmen aufGraphen von grundlegender Bedeutung.

Analyse anhand zweier Parameter:n =| V | . . . Anzahl Knotenm =| E |, 0 ≤ m ≤ n2 . . . Anzahl Kanten1

Man unterscheidet zwischen dichten Graphen, m ≈ n2, und dunnen Gra-phen, m ≪ n2, wie etwa Baumen oder Hyperkuben (m = d

2 · n = O(n logn),wenn d die Dimension des Hyperkubus ist).

Dementsprechende Speicherung:

Adjazenz–Matrix: Matrix A[1..n, 1..n]

A[i, j] =

1 wenn(i, j) ∈ E

0 sonst

Speicher Θ(n2), fur dichte Graphen praktisch, da Kantentest in O(1) Zeit.

Adjazenz–Listen: Lineares Feld F [1..n], F [i] zeigt auf lineare Liste von Kno-ten, die mit dem i–ten Knoten adjazent sind.

Beispiel: Ungerichteter Graph

1 2

34

0 1 0 0

1 0 1 1

0 1 0 1

0 1 1 0

1

2

3

4

A =

1 2 3 4

F: 1 2 3 4

1 2 2

3 4 3

4

2

↑symmetrisch, wenn Graphungerichtet

←Pro Knoten 1 Eintrag, pro Kantezwei ⇒ Θ(n+m) Speicher. Die kNachbarn eines Knotens in Zeit Θ(k)

8.3 Suchen in Graphen

Wie bei Baumen (Haupt–, Nebenreihenfolge) gibt es verschiedene Reihenfol-gen zum Durchsuchen von Graphen. Viele Algorithmen bauen auf Suchen inGraphen auf.

1≤(n2

)bei ungerichteten Graphen


8.3.1 Suchen in die Breite (BFS–Breadth First Search)

Startknoten s,”von s aus wird in alle Richtungen gleichmaßig gesucht“

Wiederholung: Abstand zweier Knoten u und v im ungewichteten Graph G :dG(u, v) = Anzahl Kanten auf kurzestem Weg von u nach v.

BFS: Zuerst s, dann alle Knoten u mit dG(s, u) = 1, dann alle Knoten u mitdG(s, u) = 2 usw. Es wird also ein Baum mit Wurzel s durchlaufen, dessen Asteaus kurzesten Wegen zu s bestehen. Dieser wachst an den Blattern. Zur Ver-waltung der Baumstruktur werden jedem Knoten folgende Werte zugewiesen:

vor(u) Vorganger von u im BFS–Baumstatus(u) neu (unbesucht), beschriftet (besucht),

gesattigt(alle Nachbarn besucht)

Knoten werden in der Reihenfolge, in der sie besucht werden, mit ihrer BFS–Nummer num(u) beschriftet. Eine Schlange Q enthalt alle beschrifteten, un-gesattigten Knoten.

Pseudo Code:

BFS(G,s)for all u ∈ V do status(u)=neu odstatus(s)=beschriftetnum(s)=1; i=2; vor(s)=nilPUT(s)while Q = 0 do

GET(u)for all v ∈ A(u) do /* alle Nachbarn von u testen */

if status(v)=neuthen

status(v)=beschriftet; num(v)=ivor(v)=u; PUT(v); i = i+ 1

fiod[status(u)=gesattigt]

od

Laufzeitanalyse Jeder Knoten kommt nur einmal in die Schlange: Θ(n). Kommter wieder heraus, wird seine Adjazenzliste durchlaufen: Θ(ρ(v)), wenn ρ(v) derGrad (Anzahl Nachbarn) von v ist:

∑v∈V

ρ(v) = 2m, da jede Kante zu zwei Listen

beitragt. ⇒ Θ(n+m) Zeit (und Speicher) fur BFS, also linear in der Große desGraphen.

Anwendungen bei ungewichteten Graphen: Alle kurzesten Wege zu s sindim BFS–Baum (Vor–Zeiger) codiert. Kurzeste Abstande konnen leicht mitge-rechnet werden: d(s) = 0; d(v) = d(u)+1; (d(u) = dG(s, u))⇒ Durch n-fachenAufruf von BFS kann die Distanzmatrix in Θ(n ·m) Zeit berechnet werden (Dader Graph zusammenhangend ist ⇒ m ≥ n− 1).

8.3 Suchen in Graphen 67

8.3.2 Erkennen bipartiter Graphen

G(V,E) heißt bipartit, wenn eine Partition von V in V1, V2 so existiert, daßnur Kanten (u, v) ∈ E mit u ∈ V1 und v ∈ V2 (oder umgekehrt) vorkommen.

V V1 2

G enthalt keine Kanten innerhalb V1

bzw. V2.

Ein Graph heißt k–farbbar, wenn seine Knoten mit ≤ k Farben so gefarbt wer-den konnen, daß keine zwei gleichfarbigen Knoten durch eine Kante verbundensind.

k=3

χ(G) = min kchromatische Zahl (sprich ’Chi von G’)

χ(Kreis) =

2 n gerade

3 sonst

χ(K4) = 4

Beobachtung: G 2–farbbar ⇔ G bipartit

⇒ Algorithmus: Durchlaufen von G in BFS–Reihenfolge; Knoten u rot⇒ farbeungefarbte Nachbarn blau, teste gefarbte Nachbarn, ob blau2.

2Hinweis: Analog: Landkarten. → 4–Farbensatz: 1975 Computerbeweis, siehe auchhttp://www.math.gatech.edu/∼thomas/FC/fourcolor.html. Dort wird fur dieses Problemauch ein Algorithmus mit quadratischer Laufzeit gezeigt. Die Berechnung der chromatischenZahl fur allgemeiner Graphen ist NP-hard, siehe Kapitel 11


8.3.3 Suchen in die Tiefe (DFS–Depth First Search)

DFS erforscht den Graphen vom zuletzt besuchten Knoten aus, der noch unbe-suchte Nachbarn hat. Spezialfall G ist Baum ⇒ DFS–Ordnung = Hauptreihen-folge

a

b c

d e f g h

i j

Stapel ST, enthalt besuchte, abernoch nicht gesattigte Knoten.HR: abdecfijgh

Pseudo Code fur allgemeine (auch gerichtete) Graphen:

DFS–SUCHE(G)for all u ∈ V do

status(u)=neuvor(u)=nil

odfor all u ∈ V do ← Schleife bei zusammenhangenden Graphen nicht notwendig

if status(u)=neuthen TIEFE(u) ← Rekursion ersetzt Stapel!

TIEFE(u)status(u)=besucht; write(u)for all v ∈ A(u) do /* alle Nachbarn von u testen */

if status(v)=neuthen vor(v)=u

TIEFE(v)fi

odstatus(u)=gesattigt

a b c

d e f

Wurzel

Die Vor–Zeiger bilden eine Menge von Baumen (DFS–Wald); jeder Aufruf vonTIEFE im Hauptprogramm liefert neue Wurzel.

Laufzeitanalyse: TIEFE wird pro Knoten genau einmal aufgerufen (nur furneue Knoten, die dann sofort als besucht markiert werden). Ein Aufruf vonTIEFE(v) braucht O(ρ(v)) Zeit ⇒ Θ(n+m) Gesamtzeit.

8.4 Planare Graphen 69

8.4 Planare Graphen

Zwei Graphen G = (V,E) und G′ = (V ′, E′) heißen isomorph, wenn es eineBijektion ϕ : V → V ′ gibt, sodaß (v, w) ∈ E ⇔ (ϕ(v), ϕ(w)) ∈ E′ gilt.

Beispiel:

2

1 4

3

1

2

3

4

Definition 1: Ein Graph G = (V,E) heißt planar genau dann, wenn eineinjektive Abbildung von V in die Euklidische Ebene und eine Abbildung von Ein paarweise disjunkte Kurvenstucke in der Ebene existieren, sodaß

1. e = (xi, xj)⇒ Kurve (e) verbindet Punkt (xi) mit Punkt (xj)

2. e = (xi, xj)⇒ Kurve (e) enthalt keinen anderen Punkt (xk), k = i, j

Definition 2: Ein Graph heißt planar, wenn er in der (Zeichen–) Ebene ohneuberschneidungen (kreuzungsfrei) dargestellt werden kann.

Eine Darstellung eines Graphen heißt plan, wenn sie kreuzungsfrei ist. Einenicht plane Darstellung eines Graphen heißt plattbar, wenn sie zu einem pla-naren Graphen isomorph ist.

Beispiele nicht plattbarer Graphen:

K 3,3

K 5

Kuratowski Graph

Satz von Kuratowski (ohne Beweis): Ein Graph G ist planar genau dann,wenn er keinen Teilgraphen G′ besitzt, der isomorph zu einer Unterteilung desK3,3 bzw. K5 ist. (Eine Unterteilung eines Graphen entsteht durch Hinzufugenvon Knoten auf den Kanten).


Beobachtung: Ein planarer Graph zerlegt die Ebene in Regionen (Flachen,faces)

Eulerscher Polyedersatz:Gegeben sei ein zusammenhangender, planarer Graphmit genau f Regionen, n =| V |≥ 1,m =| E |. Dann gilt: n+f = m+2. (AndereFormulierung: Knoten - Kanten + Flachen = 2)

Beweis: Ubung (Hinweis: Zeige, daß ein Baum als Teilgraph existieren muß,daß fur diesen der Satz erfullt ist und beobachte, was durch das Hinzufugenweiterer Kanten geschieht).

11

12

13

14

10

9

1

2

3

5

67

84

n=14m=13f=1

14+1=13+2

4

2

31

7

6

8

1715

16

1413

9

5 10

11

12

18

12 3

45

n=18m=21f=5

18+5=21+2

Satz Fur einen planaren, zusammenhangenden Graphen mit ≥ 3 Knoten gilt:| E |≤ 3· | V | −6; (m ≤ 3 · n− 6)

Beweis: Sei n =| V |,m =| E |, f = # Regionen des Graphen. Weiters seiei, i = 1..f die Anzahl von Kanten, welche die Region i umschließen. Dann gilt:

•f∑

i=1

ei ≥f∑

i=1

3 = 3 · f (da ei ≥ 3)

•f∑

i=1

ei = 2 ·m (jede Kante wird in der Summe genau einmal von links und

einmal von rechts gezahlt)

• Daraus folgt bereits 3f ≤ 2m

• Aus dem Eulerschen Polyedersatz folgt:3 ·m+ 6 = 3 · n+ 3 · f ≤ 3 · n+ 2 ·mund damitm+ 6 ≤ 3 · n bzw. m ≤ 3 · n− 6

Beachte: Bedingung notwendig, nicht hinreichend fur Planaritat (vergleiche z.B.K3,3)!

Beispiel fur Anwendung des Satzes: Behauptung: K5 ist nicht planar.Beweis: Annahme K5 ist planar, dann gilt nach Satz von Euler: n = 5,m =(52

)= 10 ⇒ f = m − n + 2 = 7. Also mußte weiters gelten: m ≤ 3 · n − 6 ⇔

10 ≤ 3 · 5 − 6 = 9, Widerspruch. Daher kann K5 nicht planar sein! (Hinweis:Es genugt auch der Widerspruch zu 2 ·m ≥ 3 · f)

Kapitel 9

Minimale Spannbaume


Die Grundaufgabe lautet etwa: ’Schaffe Verbindung zwischen n Platzen mitminimalen Kosten.’ Mehr formal: Fur eine gegebene Menge von Knoten ist einBaum gesucht, der alle Knoten mit minimaler Kanten-Gesamtlange verbindet1.

n=2 Gerade,allgemeinSpannbaum

Anwendung: Radwege-Netz, elektrische Schaltkreise, Telefonnetz . . .Verbindung von A nach B nicht immer moglich bzw. nicht proportional zurEntfernung (Bergstraße) ⇒ betrachte daher gewichtete Graphen.

Graph G = (V,E), w : E → R+ Gewichtsfunktion.

Minimaler Spannbaum von G: Baum T = (V,E′); E′ ⊂ E, sodaßw(T ) =

∑e∈E′

w(e) minimal.


72 KAPITEL 9. MINIMALE SPANNBAUME

12

3

4

5

6

7

8

9

w(T)=1+3+2+7+4=17

G hat im Allgemeinen zu viele (exponentiell) ver-schiedene Spannbaume. Alle haben genau n − 1Kanten, ihr Gewicht ist aber verschieden. (Hin-weis: Aktuelle Schranken zur Anzahl verschiede-ner Spannbaume auf Punktmengen: Ω(6.75n),O(229.33n),Punktmenge mit maximale bekannter Anzahl: 10, 42n.)

MSB(G) kann durch einen einfachen Einfugealgorithmus2 Kante fur Kanteaufgebaut werden:

E′ = 0while | E′ |< n− 1 do

wahle Kante e ∈ E \ E′, die”gut“ fur E′ ist.

E′ = E′ ∪ eodwrite E′

Kante e /∈ E′ ist gut fur E′, wenn E′ ∪ e Teilmenge eines (kann mehrdeutigsein) MSB fur G ist.

9.2 Charakterisieren guter Kanten

Schnitt von G = (V,E) ist eine Partition von V , (V1, V2)

externe Kanten

V V21

Kante (u, v) heißt intern, wenn u, v ∈ V1 oder u, v ∈ V2; sonst extern (bezuglichdes Schnittes).

Satz: Sei (V1, V2) ein Schnitt von G und X eine Teilmenge von Kanten vonMSB(G) die alle intern bezuglich des Schnittes sind. Dann ist die leichteste ex-terne Kante von G, e, gut fur X.

Beweis:3 Ist e Kante von MSB ⇒ X ∪ e ⊂MSB, fertig.

2Ein sogenannter Greedy–Algorithmus: Fuhre immer den momentan lokal optimalenSchritt als nachsten aus. Es gibt eine weite Klasse solcher Algorithmen, jedoch sind naturlichnicht alle Probleme fur diese einfache Methode geeignet (siehe z.B. Matroid-Theorie) (“greedy”bedeutet “gierig”)

3Wir nehmen an daß alle Gewichte verschieden sind. Dann ist der MSB eindeutig und derBeweis ubersichtlicher. Der Satz ist jedoch auch ohne diese Annahme korrekt.

9.3 Methode von Prim [1957] 73

u

v

fe

MSBSchnittX interne leichteste externe Kante /∈ Baumf extern ∈ Baum

Sonst ist e keine Kante von MSB⇒ e schließt einen Zyklus C ′ im Baum. C ′ hatmindestens eine externe Baumkante f (weil u und v im MSB verbunden, aberauf verschiedenen Seiten des Schnittes).Es gilt w(f) > w(e) per Definition von e. ⇒ MSB \ f ∪ e ist ein Baum,dessen Gewicht kleiner ist als das von MSB Widerspruch

Es folgen zwei Implementierungen des vorigen Greedy–Algorithmus (immer je-weils “lokal” beste Kante nehmen). Der Unterschied zwischen den Methodenliegt im Setzen der Schnitte.

9.3 Methode von Prim [1957]

Generischer Schritt: 4

X ist Teilbaum von MSB, e ist leichteste Kante mit genau einem Knoten in X.

1

2

3

4

5

6

7

8

9

bel. Wurzel r

Prioritat p(v): Gewicht der leichtesten Kante, die v mit dem Teilbaum X ver-bindet, v ∈ X.Nachbar n(v): Knoten in X, der p(v) realisiert, d.h. w(v, n(v)) ist minimalWarteschlange Q: Enthalt alle Knoten die nicht in X liegen, organisiert nachPrioritaten (z.B. in einer Halde).



Pseudo Code:

PRIM–MSB(G,r)p(r) = 0; p(v) =∞ ∀v ∈ V \ rn(r) = nilfor all v ∈ V do EINFUGE(v,Q) odwhile Q = 0 do

u = MIN(Q) /* nachster Knoten fur Baum */write(u, n(u))for all v ∈ A(u) do /* teste alle Nachbarn v von u */

if v ∈ Q and p(v) > w(u, v)then

p(v) = w(u, v) /* Prioritat verandert */n(v) = u

u

v

n(u)

XhierMSTfertig

Laufzeitanalyse: O(n+ n logn+∑v∈V

ρ(v) · log n) = O(m · log n)

ρ(v). . . Grad des Knotens v n. . . Aufbau der Halden logn. . .MIN entfernenlog n. . . p(v) anpassen⇒ O(m log n)

Speicheranalyse: O(m+ n) = O(m)

Beachte:

• MST wachst bei der Wurzel beginnend immer als zusammenhangenderBaum.

• Verkleinern von p(v) bewirkt, daß sich v in der Halde nach oben bewegt.⇒ O(log n) Zeit.

• Test auf v ∈ Q in O(1) Zeit, wenn Bitvektor fur Knoten verwendet.

• Laufzeit kann auf O(n2) gebracht werden. Dies ist sinnvoll fur dichte Gra-phen (siehe Anmerkungen zum Algorithmus von Dijkstra im nachsten Ka-pitel).

9.4 Methode von Kruskal [1956] 75

9.4 Methode von Kruskal [1956]

Generischer Schritt:X Menge von Teilbaumen (=beliebige, kreisfreie Kantenmenge) von MSB.e leichteste Kante, die keinen Kreis in X schließt. (D.h. im Gegensatz zur Me-thode von Prim wachsen hier mehrere Teilbaume gleichzeitig.)

1

2

3

4

5

6 7

8

9

• Kantenmenge E nach Gewicht sortieren: e1, e2, . . . , em, sodaß w(e1) <w(e2) < · · · < w(em). Die Kanten werden in dieser Reihenfolge eingefugt.

• Knoten durchnumerieren: v1, v2, . . . vn (beliebig).

• UNION–FIND Struktur auf V spiegelt die Teilbaume vom MSB widerund halt die Zerlegung M1,M2, . . . ,Mt von V aufrecht:FIND(x) liefert Index i wenn x ∈Mi

UNION(i,j) bewirkt Mi = Mi ∪Mj

M ′is sind die Knotenmengen der Teilbaume

Pseudo Code:

KRUSKAL–MSB(G)for i = 1 to n do Mi = vi odfor k = 1 to m do /* Kanten mussen bereits sortiert vorliegen */

(u, v) = ek /* ek=k–kurzeste Kante */i = FIND(u)j = FIND(v)if i = j then /* kein Kreis */

write ekUNION(i,j)

Laufzeitanalyse: Es erfolgen 2m FINDS und n−1 UNION Operationen. Wer-den FINDS favorisiert (Baume der Hohe 1 mit Umkehrspeicherung), brauchtdies O(m + n log n) Zeit. Der Aufwand fur Sortieren, O(m logm) Zeit, domi-niert daher.Gesamt ergibt sich O(m · log n) = O(m · logm) Zeit!

Speicheranalyse: O(n+m) = O(m)


Bemerkungen:

• Beide Algorithmen sind auch fur negative Kantengewichte geeignet: Dadie Anzahl der Kanten im MSB immer gleich groß ist, kann einfach einfester Offset addiert werden, um alle Kantengewichte positiv zu machen.Die Losung muß naturlich um den entsprechenden Betrag (Anzahl Kantendes MSB mal Offset) korrigiert werden. (Beide Algorithmen arbeiten auchohne diese Modifikation korrekt.)

• Soll die Berechnung des MST fur eine Punktmenge in der Ebene mit eukli-discher Distanzfunktion durchgefuhrt werden (geometrische Version), soist dies in O(n log n) Zeit moglich.Zentrale Beobachtung dabei ist, daß der MST ein Teilgraph der Delaunay-Triangulierung dieser Punktmenge ist (vergleiche Kapitel 7 uber Triangu-lierungen bzw. entsprechende Kapitel der Lehrveranstaltung GeometrischeAlgorithmen).

Kapitel 10

Kurzeste Wege in Graphen


Viele Algorithmen auf Graphen beruhen auf der Berechnung von”Abstanden“

zwischen Knoten. (z.B. Entfernung zwischen wichtigen Punkten.)

Abstand d(u, v): Lange des kurzesten Weges von u nach v (im Graph G, Gzusammenhangend)G ungewichtet: Anzahl KantenG gewichtet:

∑Kantengewichte

1 2

v5u

∆–Ungleichung kann verletzt sein.

Suchen in die Breite (BFS) ab Startknoten s liefert im ungewichteten Fall d(v, s)fur alle v ∈ V in Θ(m) Zeit ⇒ Θ(n ·m) Zeit fur Distanzmatrix D = (dij),dij = d(vi, vj), 1 ≤ i, j ≤ n.

Fur Kantengewicht = 1 ist die Situation komplizierter. Wir besprechen denklassischen

”kurzesten–Wege–Algorithmus von Dijkstra“ [1959] und seine O(n ·

m log n)–Implementation zur Berechnung der Distanzmatrix.

10.2 Algorithmus von Dijkstra

ahnlich wie BFS: Startknoten s, es wird der kurzeste Weg von s zu allen v ∈ Vberechnet (Baumstruktur+Lange).

Generischer Schritt: Menge T , fur alle v ∈ T ist d(v, s) bereits berechnet.Man wahlt u ∈ V − T , dessen bislang gefundener kurzester Weg nach s mini-mal ist. ⇒ pro Knoten v speichert man L(v) =, die Lange des bisher kurzesten

78 KAPITEL 10. KURZESTE WEGE IN GRAPHEN

Weges1 von s nach v (vergleiche MSB-Methode von PRIM).

L(v) =

d(v, s) wenn v ∈ T

∞ wenn v nicht mit T benachbart

kurzester Weg von s nach v uber T wenn v /∈ T , v mit T benachbart

Pseudo Code:

Programm Dijkstra(G,s) u

s

T

Q

for all v ∈ V do L(v) =∞ odL(s) = 0vor(s) = nilQ = Vwhile Q = 0 do

u = min(Q)for all v ∈ A(u) do

if L(v) > L(u) + w(u, v)then L(v) = L(u) + w(u, v) /* Q entsprechend umorganisieren */

vor(v)=u

Q ist eine nach L organisierte Warteschlange, die nicht T , sondern das Komple-ment V − T enthalt (also die noch zu bearbeitenden Knoten). → L–Werte vonKnoten in Q werden vermindert, O(log n) Zeit pro Knoten.

Laufzeitanalyse: O(n) +O

( ∑u∈V

(1 + ρ(u)) log n

)= O((n+m) log n) = O(m · log n), da Graph zusammenhangend.⇒ Distanzmatrix in O(n ·m log n) Zeit.

Korrektheit:Wir haben zu zeigen:

1. Fur alle u ∈ T gilt L(u) = d(s, u)

2. Fur jedes u /∈ T ist L(u) die Lange des kurzesten Weges von s nach uin T . (oder L(u) =∞)

Beweis:

Wir verwenden Induktion uber | T |. Nach dem ersten Durchlauf sind dieBedingungen erfullt: L(s) = d(s, s) = 0, L(u) = w(s, u) fur alle u ∈ A(s),T = s.Induktions–Schritt: u kommt zu T (wird aus Q entfernt).


10.3 Floyd–Warshall Algorithmus 79

T

L(x)

s

x

u Annahme: L(u) > d(s, u). (< nicht moglich) → Da L(u) nachInduktionsvoraussetzung den kurzesten Weg zu u in T mißt,kann der echte kurzeste Weg π nicht vollstandig in T liegen.Sei x der erste Knoten in π mit x /∈ T . Der Teil von π bis xliegt also ganz in T . Dieser Teil ist aber der kurzeste Weg vons nach x (Optimalitat von Teilwegen)⇒ L(x) = d(s, x) (nachInduktionsvorraussetzung 2). Wegen d(s, x) < d(s, u) ≤ L(u)folgt L(x) < L(u) Widerspruch zu u = min(Q), da x, u ∈ Q.Es gilt also L(u) = d(s, u), d.h. Punkt 1) wird aufrechterhalten.

Punkt 2) wird ebenfalls Rechnung getragen: u kommt zu T und kann nur furv ∈ A(u) den L(v)–Wert verkleinern.

Bemerkungen

• Beachte die Ahnlichkeit des vorgestellten Algorithmus mit der Methodevon Prim zur Berechnung minimaler Spannbaume (Kapitel 9.3): nur dieBerechnung der Prioritaten (p bzw. L) ist verschieden.

• Trotz Verwendung fortgeschrittener Datenstrukturen (Warteschlange) istDijkstra fur dichte Graphen (m = Θ(n2)) nicht sehr effizient: Θ(n3 log n)Zeit und Θ(n2) Speicher. → Zeit wird im folgenden Kapitel um log n–Faktor verbessert.

• Wird fur die Warteschlange Q eine unsortierte Liste verwendet, so erhaltman eine Laufzeit von O(

∑u∈V (n+ ρ(u) · 1)) = O(n2+m) = O(n2). Dies

ist zwar schlecht fur dunne Graphen, aber gut, wenn nur dichte Graphenuntersucht werden sollen, da dann die Laufzeit zur Berechnung der Di-stanzmatrix O(n3) betragt. (Vergleiche auch den Algorithmus von Prim.)

• Fur Graphen mit negativen Kantengewichten kann der Algorithmus vonBellman-Ford eingesetzt werden. Dieser ermittelt auch ob vom Startkno-ten aus ein Kreis mit negativem Gewicht erreicht werden kann. In diesemFall existiert keine endliche Losung, anderenfalls wird die Optimallosungin O(n ·m) Zeit berechnet.

10.3 Floyd–Warshall Algorithmus

Im folgenden Verfahren erfolgt eine Direktberechnung der Distanzmatrix. Diedabei zugrundeliegenden Beobachtungen sind ahnlich denen beim dynamischenProgrammieren (vergleiche Kapitel 3).

Gegeben ist ein gewichteter Graph G = (V,E), V = v1, . . . , vn und eineGewichtungsmatrix w

w(i, j) =

w(vi, vj) wenn (vi, vj) ∈ E

0 wenn i = j

∞ sonst

Wir betrachten eine Folge von Matrizen w1, . . . , wn aus w mittels

wk(i, j) = minwk−1(i, j), wk−1(i, k) + wk−1(k, j)

80 KAPITEL 10. KURZESTE WEGE IN GRAPHEN

wobei w0 = w.

Satzwn(i, j) = d(vi, vj), ∀i, j

Beweis: Wir zeigen durch Induktion uber k daß wk(i, j) die Lange des kurzestenWeges von vi nach vj uber v1, . . . , vk ist.Induktions–Anfang: Stimmt fur k = 0, da direkte Kante.Induktions–Schritt: Sei die Aussage richtig fur k−1. Betrachte wk. Der kurzesteWeg von vi nach vj uber v1, . . . , vk kann vk enthalten oder nicht. Im ersten Fallhat er Lange wk−1(i, k)+wk−1(k, j) laut Induktionsvoraussetzung, da zwischenvi, vk bzw. vk, vj nurv1, . . . , vk−1 zahlt.

v , ... ,v 1 kvi

kvvj

aus v , ... ,v 1 k−1

Im zweiten Fall beeinflußt vk die Lange nicht, also Lange wk−1(i, j).Der Algorithmus nimmt das Minimum. Zum Schluß ist wn(i, j) die kurzesteEntfernung in V , also = d(vi, vj).

DISTANZMATRIX(G)w0 = wfor k = 1 to n do

for i = 1 to n dofor j = 1 to n do

wk(i, j) = minwk−1(i, j), wk−1(i, k) + wk−1(k, j)

Analyse:Zeit Θ(n3)Speicher Θ(n2)

Bemerkung: Obige Methode entspricht exakt dem Entwurfsprinzip ’Dynami-sches Programmieren’, wie auch leicht aus dem Quelltext ersichtlich ist. Hierwurde lediglich eine etwas andere Methode der Herleitung der Zusammenhangegewahlt. (Ubung: Algorithmus und Beweis uber dynamisches Programmierenherleiten!)

Teil IV

Komplexitatstheorie

Kapitel 11

NP–vollstandige Probleme

11.1 Was sind NP–vollstandige Probleme?

• Fur alle bisher besprochenen Probleme konnte eine (einigermaßen) befrie-digende algorithmische Losung gefunden werden.Etwa: Θ(n3) fur optimale Triangulierungen

Θ(nlog2 3) fur Multiplikationen langer Zahlen

• Es ergibt sich folgende Frage: Sind alle Probleme in Zeit O(nk) losbar,k unabhangig von n (polynomiale Zeit)?Antwort: NEIN! (Es gibt sogar wohlformulierte Probleme, die uberhauptnicht losbar sind; Unentscheidbarkeit, Turingsches Halteproblem etc.)

• Bemerkung: Es genugt die Laufzeit–Analyse. In f(n) Zeit kann nurO(f(n))Speicher belegt werden. ⇒ S(n) = O(T (n))

• Losbarkeit in polynomialer Zeit markiert die Trennlinie zwischen”behan-

delbaren“ Problemen und”unbehandelbaren“, aus praktischer Sicht. ⇒

Der Problemstatus ist entscheidend!1

Kuriosum: Es gibt eine wichtige Klasse von Problemen, deren Statusungeklart ist, die sogenannten NP–vollstandigen2 Probleme.

11.1.1 Eigenschaften NP–vollstandiger Probleme

• Man kennt keinen polynomialen Algorithmus, aber auch keine superpoly-nomiale untere Laufzeitschranke.

• Kann fur ein beliebiges solches Problem der Status entschieden werden,dann fur alle Probleme in der Klasse.

• Viele solche Probleme sehen anfangs nicht schwerer aus als Sortieren oderGraphensuche.

1Es gibt auch Probleme deren Komplexitat zwischen diesen Klassen liegt, z.B. mit LaufzeitO(nlogn).

2Die Abkurzung NP steht fur Nondeterministic Polynomial.

84 KAPITEL 11. NP–VOLLSTANDIGE PROBLEME

11.1.2 Geometrisches Rundreiseproblem

Ahnlich dem Traveling Salesman Problem (TSP): Gegeben sind n Punkte in derEbene, gesucht ist der kurzesten Zyklus, der alle Punkte genau einmal besucht.

Zum Vergleich: MSB (Minimum Spanning Tree)

TSP: NP-vollständig

NP–vollstandigNaiv: Teste n!/(2n) = 1

2 (n− 1)!verschiedene Zyklen.

MSB: O(m log n)m = O(n2)

Beide Probleme”sehen ahnlich aus“, besitzen aber vollig unterschiedlichen Pro-

blemstatus.

11.2 Einteilung in Problemklassen

11.2.1 Was ist mit Problem gemeint?

Beispiel: Abstande in Graphen.Einzelproblem3: Graph G, Knoten u, vLosung: Anzahl der Kanten auf kurzesten Weg in G von u nach v.Problem: gesuchte Relation, die Einzelprobleme auf ihre Losung abbildet (“Koch-rezept”, Algorithmus, Formel etc.).

Beachte: Ein Algorithmus lost ein Problem, wenn er die zugehorige Relationsimuliert. (D.h. jedes Einzelproblem (Input) in die richtige Losung (Output)uberfuhren kann!)

11.2.2 Optimierungsproblem–Entscheidungsproblem

JedesOptimierungsproblem (kurzester Weg, minimaler Spannbaum, . . . ) hatein zugehoriges Entscheidungsproblem (Output ja/nein), das im Allgemei-nen leichter zu losen ist (aber nicht immer):

Beispiel: Einzelproblem (G, u, v, k), G ungewichtet:Entscheidungsproblem: Ist dG(u, v) ≤ k ?Kann man dies entscheiden, dann bekommt man dG(u, v) wie folgt:

• Alle Wege haben Lange zwischen 0 und n− 1.

• Probiere alle Werte fur k.Gibt es einen Weg der Lange k, aber nicht der Lange k−1⇒ k = dG(u, v).

• Besser: Binare Suche, O(log n) Schritte.

3engl. Instance

11.2 Einteilung in Problemklassen 85

Kann also das Entscheidungsproblem in O(f(n)) gelost werden, so kann auchdas Optimierungsproblem in O(g(n) · f(n)) gelost werden, wobei g(n) eine po-lynomiale Funktion in n ist.

11.2.3 Warum Entscheidungsprobleme?

1. Um zu zeigen, daß ein Problem NP-vollstandig ist, genugt es, die Entscheidungs–Version als NP-vollstandig zu erkennen.

2. Entscheidungsprobleme sind meist leichter zu handhaben. Verifizieren derLosung eines Entscheidungsproblems meist einfach.

3. Bezug zu formalen Sprachen:L = (G, u, v, k) | G = (V,E), u, v ∈ V mit dG(u, v) ≤ k.Entscheidungsproblem ≡ L(Sprache)Einzelproblem ≡ Wort x der Form (G, u, v, k)(x ∈ L)4 entscheiden (∀x)5 ≡ Problem losen

Problemklasse P: Menge von Entscheidungsproblemen, die in polynomialerZeit losbar sind.

Problemklasse NP: Menge von Entscheidungsproblemen, fur die eine gege-bene Losung in polynomialer Zeit verifiziert werden kann.

Verifizieren ist fur Entscheidungsprobleme im Allgemeinen leichter als Losen.

Beispiel: Sortieren von n Zahlen in Ω(n log n) Zeit, Test auf Sortiertheit in O(n)Zeit.

Beispiel: Hamiltonscher Kreis:

Ein Graph G ist hamiltonsch wennein Zyklus in G existiert, der alle

Knoten von G genau einmalbesucht. Es ist kein polynomialerAlgorithmus fur dieses Problembekannt. Verifizieren geht leicht inO(n2), bzw in linearer Zeit wenn dieAdjazenz Matrix gegeben ist.⇒ Das Problem Hamiltonscher Kreisist ∈ NP.

Generell gilt P ⊆ NP, da Verifizieren durch Losen und Vergleichen geschehenkann.

4entsprechende Codierung vorausgesetzt!5mit Turingmaschine


Beispiel: Optimale Triangulierung konvexer Polygone als Entscheidungsproblem(’Kann mit maximaler Gesamtlange l trianguliert werden?’):Losen in Θ(n3), Lange mit der zu verifizierenden Losung vergleichen in Θ(n).Damit gesamt polynomial, O(n3).

11.3 Fundamentale offene Frage: P?= NP

Oder aquivalent:

• NP−P= ∅?

• Gibt es polynomiale Algorithmen fur alle Probleme, deren Losung schnellzu verifizieren ist?

11.3.1 NP–P

NP–P ist entweder leer oder enthalt viele interessante und wichtige Probleme:

• Rundreise (TSP), geometrische Rundreise

• Erfullbarkeit boolscher Formeln (SAT)

• Minimum Weight Triangulation (MWT)

• Schedulingprobleme

• Viele Probleme auf Graphen wie z.B. hamiltonscher Kreis, maximale Cli-que6, u.s.w.

• Zahlreiche Optimierungsprobleme, z.B. Quadratic Assignment Problem ...

• Geometrische Probleme, z.B. Plazierungsprobleme ...

Alle diese Probleme sind NP–vollstandig:Wenn eines davon in P ist, dannalle! Der Grund dafur wird im folgenden Abschnitt erlautert.

11.3.2 Polynomial reduzierbar

Problem B ist (polynomial) reduzierbar auf Problem A, B≤A (B≤pA), wennjedes Einzelproblem x ∈B (in polynomialer Zeit) als ein solches, y ∈A formuliertwerden kann und wenn aus der Losung von y die Losung von x (in polynomialerZeit) ableitbar ist.

Beispiel: Losen linearer Gleichungen reduziert sich auf Losen quadratischer Glei-chungen:Einzelproblem: ax+ b = 0,reformuliert: 0x2 + ax+ b = 0.Losung aquivalent.

6Als Clique bezeichnet man einen vollstandigen Teilgraphen, z.B. K5

11.4 Beispiele NP–vollstandiger Probleme 87

Definition: Problem A ist NP–vollstandig, wenn A ∈ NP und A′ ≤p A furalle A′ ∈ NP .

NP–vollstandige Probleme sind also die”schwersten“ Probleme in NP. Ihre Zeit-

komplexitat ist bis auf einen polynomialen Faktor gleich groß.

11.3.3 NP–Vollstandigkeits–Beweis

Wie zeigt man nun, daß ein Problem A NP–vollstandig ist?

1. Zeige A ∈ NP (meist leicht, verifizieren)

2. Wahle ein bereits als NP–vollstandig bekanntes (geeignetes) Problem B,und zeige, daß B ≤p A. (D.h. A nicht leichter als B)

Beispiel Rundreise in Graphen:Rundreise in gewichteten, vollstandigen Graphen Kn, RR = (Kn, k) | Gibt eseinen Zyklus durch alle Knoten, mit Lange ≤ k? (Beachte: Kn enthalt immereinen Zyklus.)

Satz: RR ist NP–vollstandig.

Beweis:1) Fur einen gegebenen Zyklus kann seine Lange in O(n) Zeit auf ≤ k getestetwerden. ⇒ RR∈NP.2) (Reduktionsbeweis) Wir wahlen

”Hamiltonscher Kreis“, H, als NP–vollstandiges

Problem und zeigen H ≤p RR.Wir formulieren jedes Einzelproblem G′ in H als spezielles Einzelproblem inRR: Sei G vollstandiger Graph, mit Gewichtung

w(e) =

0 e Kante in G′

1 sonst

Gibt es in G einen Zyklus mitGewicht ≤ 0 (also nur auf Kanten vonG′)? (G, 0) ∈ RR⇔ G′ ∈ HG ist in O(n2) Zeitkonstruierbar.

11.4 Beispiele NP–vollstandiger Probleme

11.4.1 Traveling Salesman Problem (TSP)

Geometrisch Gegeben sind n Punkte in der Ebene; Finde kurzesten Zyklus,


der alle Punkte besucht.Allgemein (entspricht dem Rundreiseproblem RR) Gegeben ist ein ge-wichteter, vollstandiger Graph. Finde kurzesten Zyklus durch alle Knoten.

11.4.2 Hamiltonscher Kreis

Gegeben ist ein (nicht vollstandiger) Graph. Ist dieser hamiltonsch, d.h. besitzter einen Zyklus, der alle Knoten einmal besucht?

11.4.3 SAT (formula SATisfiability)

SAT war eines der ersten (und wichtigsten!) Probleme, das als NP–vollstandigbewiesen wurde.

SAT: Gegeben ist eine boolsche Formel Φ die aus

• boolschen Variablen x1, x2, . . .

• boolscher Verknupfung (AND, OR, NOT, ⇒, ⇔)

• Klammerung

besteht.

Die Formel Φ heißt erfullbar (satisfiable), wenn es eine Wertzuweisung an dieVariablen x1, x2, . . . gibt, sodaß die Auswertung von Φ

”1“ (true) ergibt.

Das SAT Problem fragt nun, ob eine gegebene boolsche Formel Φ erfullbarist.

3 SAT: Darstellung in konjunktiver Normalform. Jede Klausel enthalt maximal3 Variablen, z.B.:(x1 ∨ x2 ∨ x3) ∧ (x1 ∨ x3 ∨ x5) ∧ (. . . )∨ . . . OR∧ . . . AND

3SAT ist ebenfsalls NP–vollstandig.

Bemerkung: 2 SAT ∈ P (kann sogar in linearer Zeit gelost werden!)

Kapitel 12

Naherungsalgorithmen furNP–vollstandige Probleme


NP–vollstandige Probleme: Algorithmen–Designer finden keinen praktischen Al-gorithmus, Theoretiker finden keinerlei Erklarung dafur.

Ausweg:

1. Heuristiken (Strategien mit guter Laufzeit in vielen Fallen)(Kann imWorst–Case aber

”entarten“1)

2. Naherungslosungen statt exakten Losungen bei Optimierungsproble-men

Wir studieren 2) Approximationsalgorithmen. Man wunscht sich polynomialeVerfahren mit guter (d.h. beweisbarer) Fehlerschranke.

12.1.1 Relativer Fehler

Definition: Algorithmus hat relativen Fehler ϵ(n), wenn fur jeden Input derLange n gilt

| L− L∗ |L∗ ≤ ϵ(n),

wobei L∗ = Wert der optimalen Losung und L = Wert der produzierten Losung.

ϵ(n) ≥ 0 stets

= 0 wenn L optimal

Ist die tatsachliche Losung also z.B. immer maximal doppelt so groß wie dieoptimale Losung, also L ≤ 2L∗, so ist der relative Fehler ϵ(n) = 1.

1Die Laufzeit kann entarten, nicht aber die Losung! Diese ist - sofern man sie im vorgege-benen Zeitrahmen uberhaupt erhalt - immer korrekt.

90KAPITEL 12. NAHERUNGSALGORITHMEN FUR

NP–VOLLSTANDIGE PROBLEME

12.1.2 Beispiel Geometrische Rundreise (≈ TSP)

Gegeben ist eine Punktmenge S in R2 mit n Punkten.Algorithmus Approx-RR(S):

1. Konstruiere MSB(S)

2. Durchlaufe MSB(S) in Hauptreihenfolge

1

2

34

56

7 8

Start/Ziel

Zyklus A

Satz Approx-RR hat relativen Fehler 1.

Beweis: Wir zeigen | A |< 2 | RR |, dabei ist A die Losung von Approx. RR(S)

und RR die exakte Losung. Dann ist |A|−|RR||RR| < 1 = ϵ(n)

1. | A |< 2 | MSB |. Jede Kante von MSB wird durch Hauptreihenfolge 2×durchlaufen, und A macht gewisse Abkurzungen. (∆–Ungleichung)

2. Es gilt aber | RR |>|MSB |. Entfernt man aus RR eine Kante, so entstehtein Spannbaum, der mindestens Lange |MSB | hat.

12.2 Polynomiales Approximationsschema

Im letzten Beispiel ist ϵ(n) unabhangig von n, gilt also fur beliebig große Punkt-mengen. Konstanter relativer Fehler kann bei vielen Naherungen nicht erreichtwerden (Beispiel optimale Triangulierung2: ϵ(n) = Θ(log n)). Es gibt aber NP–vollstandige Probleme, die in polynomialer Zeit beliebig genau approximiertwerden konnen.

Das sogenannte voll polynomiale Approximationsschema besitzt folgen-de Laufzeit:

T (n, ϵ) = poly(n, 1/ϵ)(3 (→∞ fur ϵ→ 0)

2Erst 1996 wurde auch fur dieses Problem eine konstante Approximation gefunden3d.h. die Laufzeit laßt sich als Polynom in n und 1/ϵ darstellen

12.3 Naherungslosung fur das Rucksackproblem 91

12.3 Naherungslosung fur das Rucksackproblem

Problemstellung (einfache Variante, ahnlich ’SubSetSum’):Gegeben ist X = x1, . . . , xn, m, aus NGibt es eine Teilmenge T ⊆ X mit

∑xi∈T

xi = m?

Entscheidungsproblem, NP–vollstandig.Optimierungsversion: Finde T , sodaß

∑xi∈T

xi maximal, aber ≤ m. (Beladen von

Rucksack, Eisenbahnwaggon . . . )

Es gibt exponentiell viele (2n) Teilmengen T von X. Der folgende exponenti-elle Algorithmus laßt sich zu einem voll polynomialen Approximations–Schemamodifizieren.

Sei Li Liste aller Teilsummen von x1, . . . , xi, i ≥ 0

Beispiel: X = 1,4,5L0 = 0L1 = 0,1L2 = 0,1,4,5L3 = 0,1,4,5,6,9,10

Es gilt Li = Li−1 ∪ (Li−1 + xi)(4, wobei | Li |≤ 2i

Pseudo Code:

MAXSUM(X,m)L0 = 0for i = 1 to n do

Li = Li−1 ∪ (Li−1 + xi) ← Li aufsteigend sortiert!(* Hier wird spater ausgedunnt *)Entferne aus Li alle Werte > m od

berichte Maximum von Ln

Korrektheit: Leicht zu sehen.Laufzeit: Ω(| Ln |)(5, wird i.A. exponentiell wachsen!

Man kann exzessive Listenlange vermeiden, indem man die Liste systematisch

”ausdunnt“. Der resultierende Fehler bleibt dabei kontrollierbar.Idee: Jedes a ∈ Li wird durch ein b ∈ Li, b ≤ a, reprasentiert, sodaß der relativeFehler von b bezuglich a hochstens δ ist.

| b− a |a

≤ δ

Im Beispiel sind die Reprsentanten fur δ = 1/10 eingekreist:

Li= 10 , 11 , 12 , 15 , 20 , 21 , 22 , 23 , 24 , 29 , = 1/10

Geht in Zeit O(| Li |), wenn Li sortiert.

4Def.:A+ x := a+ x | a ∈ A5≤ 2n

92KAPITEL 12. NAHERUNGSALGORITHMEN FUR

NP–VOLLSTANDIGE PROBLEME

Approx-Maxsum: Im Programm, nach Erzeugung von Li einfugen:DUNN(Li, ϵ/n), 0 < ϵ < 1 ← ϵ/n = δ

Satz: Approx-MAXSUM hat relativen Fehler ϵ.

Beweis: Pro Schritt wird derselbe relative Fehler ϵ/n = δ gemacht.|b−a|

a ≤ ϵn . Da b ≤ a gilt:

| b− a |a

≤ ϵ

n⇐⇒ a− b ≤ a

ϵ

n⇐⇒ a(1− ϵ

n) ≤ b.

Da die Werte in ausgedunnten Listen stets”echt“ sind (also Summe von

x′is), multipliziert sich der Fehler hochstens. Ist also b∗ der Output und a∗ die

wirkliche optimale Losung, dann gilt nach n Schritten:

a∗(1− ϵ

n︸︷︷︸)n ≤ b∗ ⇒ a∗(1− ϵ) ≤ b∗ ⇒ a∗ − b∗

a∗≤ ϵ

n→∞⇒ (1− ϵn )

n ⇒ e−ϵ

Daher gilt mit n monoton steigend (1− ϵn )

n ≥ (1− ϵ)

Satz: Approx-MAXSUM hat Laufzeit polynomial in n und 1/ϵ.

Beweis: Ausgedunnte Liste, benachbarte Werte b < b′:

⇒ b′ − b

b′> δ ⇔ b′(1− δ) > b

b′ > b1

1− δ= b

1

1− ϵn

Dies ist aber der Multiplikationsfaktor von einem Wert der Liste zum Nachsten,da die Werte sonst ausgedunnt worden waren. Die Werte sind ganzzahlig, dergroßte Wert ist ≤ m, der kleinste Wert ist 1. Daher gilt(

1

1− ϵn

)k

≤ m, k Listenlange, 1.Wert ≥ 1

k ≤ log1/(1−ϵ/n) m =lnm

− ln(1− ϵ

n)︸︷︷︸≤ n lnm

ϵ.

ln(1 + x) ≤ x⇔ − ln(1 + x) ≥ −x⇒ fur x = − ϵ

nfolgt− ln(1− ϵ

n) ≥ ϵ

n.

Die Listenlange k und damit die Laufzeit ist also polynomial in n und 1/ϵ.Da die Große der Schrankem nur logarithmisch eingeht (≡ Anzahl der notwendi-gen Bits, die ohnehin im Rechenmodell als konstant betrachtet wird), beeinflußtsie das Ergebnis nicht.

Teil V

Ausgewahlte Kapitel

Kapitel 13

String–Matching Verfahren


In der maschinellen Textverarbeitung ist das Finden von (Teil–) Wortern in ei-nem Text eine grundlegende Anforderung. Kein moderner Editor kommt ohnediese Funktion aus.

String matching:Text T [1..n], String P [1..m]; m≪ nT [i], P [i] ∈ Σ ... Alphabet

z.B.: Σ =0, 1 ... Binarstring

0, 1, .., 9 ... Dezimalstring,

a, b, c, .., z etc.

Problem: Finde alle Indizes k, sodaß P [1..m] = T [k..k +m− 1]

13.2 Grundlegende Algorithmen

Im Folgenden werden mehrere verschiedene Verfahren vorgestellt, die sich so-wohl im Entwurfsprinzip als auch in den zugrundeliegenden Anwendungen un-terscheiden.

13.2.1 Naiver Algorithmus

Teste fur 1 ≤ k ≤ n−m+1 ob P [1..m] = T [k..k+m− 1]. Pro Test O(m) Zeit,wenn ein Zeichenvergleich P [i] = T [j] in O(1) Zeit entschieden werden kann. ⇒Gesamt daher Θ(m(n−m+1)) Zeit, also z.B. Θ(n2) fur Strings der Lange O(n).

Dies kann fur online–Betrieb zu langsam sein! Dieser direkte Zugang ist abernicht bestmoglich:

T . . . a b a b a a b . . .P . . . a b a b a c . . .

“Weiterrucken” von P um einen Schritt nach rechts ware ungeschickt, da P an

96 KAPITEL 13. STRING–MATCHING VERFAHREN

dieser Stelle (aufgrund der bisherigen Information) nicht “matchen” kann.

. . . a b a b a a b . . .a b a b a c

a b a b a c

Man kann zwei Schritte weiterrucken, und weiß außerdem, daß die ersten 3 Zei-chen von P mit dem (bisherigen) Ende von T matchen – diese mußen dahernicht nochmals getestet werden.

Diese einfachen Beobachtungen sollen im Folgendem formalisiert und zuvollstandigen Algorithmen ausgebaut werden.

Prafix (Anfangsstuck) x von P : ∃z sodaß P = xzSuffix (Endstuck) y von P : ∃z sodaß P = zyPk ... Prafix von P der Lange k (Pk entspricht also P [1..k])

Fur den String P definierte Verschiebungsfunktion Π(): “Wenn Pk mit dermomentanen Textstelle ubereinstimmt, dann sei k−Π(k) die Anzahl der Stellen,um die P nach rechts geruckt werden darf (und kann).”

Also: Fur k = 1, 2, ..,m sei Π(k) die Lange des großten Prafix von Pk, derauch Suffix von Pk ist:

Π(k) = maxj < k | Pj Suffix von Pk

Beispiel:P . . . a b a b a cΠ . . . 0 0 1 2 3 0

Wiederholte Anwendung von Π liefert immer kurzer werdende Prafixe von P ,die mit dem momentanen Textende matchen:

Pk, PΠ(k), PΠ(Π(k)), . . .

T= . . . a b a b a a b . . . k=5 P5

P= a b a b a c Π(5)=3 P3

a b a b a c Π(3)=1 P1

a b a b a c Π(1)=0a b a b a c

Die durch Vergleichen gewonnene Information uber das momentane Textendewird somit vollstandig ausgenutzt!

Beachte: Π hangt nur von P ab, ist also vom Text T unabhangig!

13.2 Grundlegende Algorithmen 97

13.2.2 Algorithmus von Knuth, Morris, Pratt (1977)

Obige Beobachtungen fuhren nun zu dem folgenden Algorithmus 1 Dabei wirdvorerst vorausgesetzt, daß Π bereits vorab berechnet wurde.

k := 0 /* k ist die Anzahl von Zeichen von P die bisher ubereinstimmen */for i := 1 to n do

while k > 0 AND P [k + 1] = T [i] dok := Π(k)

odif P [k + 1] = T [i] then k := k + 1 fiif k = m then

write“P tritt an Stelle i-m+1 auf”k := Π(k)

Grobe Laufzeitanalyse:Pro “for” wird “while” hochstens m mal durchlaufen, wegen Π(k) < k. ⇒O(nm) Gesamtzeit.

Potentialmethode:Potential ∼= Wert von k.Jedes “for” erhoht k um ≤ 1Jedes “while” vermindert k um ≥ 1k wird nie negativ.

Betrachte nun den i–ten Durchlauf der “for”–Schleife: Wird “while” wi maldurchlaufen, so muß “for” vorher fi ≥ wi mal durchlaufen worden sein.

⇒n∑

i=1

fi︸︷︷︸≤n

≥n∑

i=1

wi ⇒n∑

i=1

wi ≤ n

⇒ hochstens n “while”–Durchlaufe, und damit O(n) Gesamtzeit (sofern Π be-reits bekannt!).

Vorab (also bevor obiger Algorithmus gestartet wird) erfolgt die Berechnungder Verschiebefunktion Π(k)

pk

p

k+1

j

Vorgang fast analog zu vorher (Selbstuberlappung!), Π[k+1] wird aus Π[k] = jberechnet.



Pseudo Code:

Π[1] := 0j := 0 /*j..Lange des (gerade aktuellen) langsten Prafix das zugleich Suffix ist */for k := 2 to m do (berechne Π(k))

while j > 0 AND P [j + 1] = P [k] doj := Π[j]

odif P [j + 1] = P [k] then j := j + 1 fiΠ[k] := j

Laufzeit O(m), analysiert mit Potential j.

Satz: Der KMP–Algorithmus lost das String-Matching Problem fur Textlangen und Stringlange m in O(n+m) = O(n) Zeit.

Dies ist im WorstCase offensichtlich optimal (der gesamte Input muß zumin-dest betrachtet werden).Beachte auch die Unabhangigkeit von der Alphabetgroße!

13.2.3 Verfahren von Karp–Rabin (1981)

Dieses Verfahren bietet einen vollig anderen Zugang zum String–Matching.Idee:Vorab–Test zur Vermeidung zu vieler Buchstabenvergleiche mittels Hashing:Fur den String P wird ein “Fingerabdruck” f(P ), f : Σ∗ → N berechnet.

Gewunschte Eigenschaften der Hash-Funktion:

(1) f(x) = f(y)⇔ x = y

(2) Sei fi = f(T [i, .., i+m− 1]). Dann ist fi+1 schnell (in O(1)) aus fi bere-chenbar.

Pseudo Code:

for i := 1 to n−m+ 1 doif fi = f(P ) then write i

Zeitanalyse: O(n)

Die Schwierigkeit liegt in der Definition von f . Zur Demonstration sei Σ =0, 1, .., 9 (alle Zeichen sind Ziffern). Wahle f(x) als Dezimalwert von x. Spe-ziell:

fi =m∑j=1

T [i+ j − 1] ∗ 10m−j

13.2 Grundlegende Algorithmen 99

Eigenschaft (1) ist erfullt, aber

ad (2):

m︷︸︸︷43951 4395139513 3951

3951039513

fi+1 = (fi − 10m−1 ∗ T [i]) ∗ 10 + T [i+m]

Problem: Zahlen werden zu groß, wenn Stringlange m großer als die Anzahldezimaler Stellen einer Integervariable ist ⇒ Laufzeitverlust (Langzahlarithme-tik ware notwendig)

Man weicht daher Punkt 1) der Definition von f auf und erhalt die Funkti-on ϕ(x):

(a) ϕ(x) = ϕ(y)⇒ x = y

(b) ϕ(x) = ϕ(y)⇒ x = y mit hoher Wahrscheinlichkeit

Las Vegas–Methode: Teste ϕ(P ) = ϕi, fur i = 0, 1, ..., n−m. Bei “ja” erfolgtein direkter Zeichenvergleich. Dieses Verfahren ist immer richtig, aber manch-mal langsam: Suche z.B. P = am in T = an ⇒ O(nm) Zeit

Monte–Carlo–Algorithmus: Erfolgt die Las Vegas–Methode ohne nachfol-genden Zeichenvergleich, so arbeitet sie immer schnell, aber manchmal inkorrekt(Vergleiche Naherungslosungen / Heuristiken, Kapitel 12)

Man verwendet als Hash-Funktion haufig: ϕ(x) = f(x) mod q. Dabei ist qeine Primzahl kleiner als die großte “intern” darstellbare Integerzahl, d.h. ϕ(x)paßt immer in eine interne Variable (einfache Prazision genugt) und erfullt For-derungen (1a,b) und (2):

Ad(1): (a) offensichtlich; (b) prob[ϕ(P ) = ϕi] ≈ 1q , daher gibt es ca. n

q “fal-

sche Matches” ⇒ Θ(nq ) ϕ–Matches zu jeweils O(m) Zeit.

Sei v die Anzahl korrekter”Matches“ (d.h. die Anzahl gefundener Strings), dann

ergibt sich gesamt O(n+m(v + nq )) Zeit

Sofern q > m gilt genugt also O(n+ vm) Zeit.

Ad (2): Modulo rechnen:(x+ y) mod b = (x mod b+ y mod b) mod b (Subtraktion analog)(x · y) mod b = (x mod b · y mod b) mod b

Satz: Das Verfahren von Karp–Rabin kann bei v korrekten Fundstellen inO(n+ vm) Zeit mit Hashing mittels Modulo–Operator durchgefuhrt werden.


13.3 Effiziente Verfahren in der Praxis

(Siehe z.B. c’t 3/95 fur einen leicht lesbaren Uberblick.)

13.3.1 Quicksearch

Idee: Stimmt der String P mit dem beim Index j beginnenden Teilstring vonT nicht uberein, so inspiziere das erste Zeichen von T nach dem String P , alsoT [j +m]. Man kann nun den Suchstring P soweit verschieben, bis das ZeichenT [j + m] mit einem Zeichen in P ubereinstimmt, denn nur dann kann es ein

”match“ geben. Im besten Fall, wenn T [j + m] nicht in P enthalten ist, kannman daher P an T [j +m] ganz vorbeischieben, also um m+ 1 Stellen.

AlgorithmusInitialisierung: Bestimme fur jedes mogliche Zeichen b in T den Index Π[b] desletzten Auftretens von b in P . Tritt b in P nicht auf, so setze Π[b] := 0Suche: Ist der Vergleich von P mit T [j . . . ] erfolglos, dann betrachte b :=T [j + m]. Der nachste Vergleich muß nun an der Stelle j + (m + 1) − Π[b]erfolgen, d.h. setze j := j +m+ 1−Π[b]

Beispiel:T=ababcacdabcbdacP=abdd, m=4

Initialisierung:

Π[a] = 1 j = 1Π[b] = 2 j = 1 + 4 + 1−Π[c] = 6Π[c] = 0 ⇒ j = 6 + 4 + 1−Π[b] = 9Π[d] = 4 j = 9 + 4 + 1−Π[d] = 10

j = 10 + 4 + 1−Π[a] = 14

Suche:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15T= a b a b c a c d a b c b d a c

a b d da b d d

a b d da b d d

a b d d

Bemerkung Quicksearch ist ahnlich der Methode von Boyer-Moore (nicht vor-gefuhrt), jedoch einfacher zu implementieren und in der Praxis effizienter. DerWorstcase von Quicksearch liegt jedoch bei O(nm)

13.3.2 Optimal–Mismatch

Basiert auf derselben Idee wie Quicksearch, zusatzlich erfolgt noch folgende Be-obachtung: Die Reihenfolge, in der die Zeichen das Strings P verglichen werden,kann frei gewahlt werden.

13.3 Effiziente Verfahren in der Praxis 101

Aus dieser Beobachtung ergibt sich, daß es sinnvoll ist, zuerst selten auftretendeZeichen im Suchstring zu vergleichen, da damit mogliche Unterschiede schnellererkannt werden konnen.

Beispiel: Suchen eines Strings in einem deutschsprachigen Text. Das Zeichen’e’ ist mit 12 % im Durchschnitt das meistbenutzte, das Zeichen ’x’ mit 0.002% das seltenste. Daher ist es sinnvoll, zB. fur das Wort “Hexe” zuerst das dritteZeichen zu vergleichen, da die Wahrscheinlichkeit eines zufalligen Ubereinstim-mens (und nur dann mussen ja weitere Vergleiche durchgefuhrt werden) hierwesentlich geringer ist, als etwa beim 2. oder 4. Zeichen.

Algorithmus:

Initialisieren:

• Berechne die relative Haufigkeit jedes Zeichens aus dem Text T (nur sinn-voll, wenn viele Abfragen fur einen Text zu erwarten sind)

oder

• Verwende vorgegebene Haufigkeitstabelle (zB. deutschsprachiger Text, Quell-text)

• Erstelle eine Tabelle fur die im Suchstring P enthaltenen Zeichen: dieseenthalt die Indizes des Auftretens der Zeichen in P und ist nach aufstei-gender Haufigkeit sortiert.

Suche: Wie bei Quicksearch, die Reihenfolge der Vergleiche der Zeichen in Perfolgt jedoch mittels der Tabelle.

Beispiel:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

T= a b a b c a c d a b c b d a cP= a b d d

⇒ Haufigkeit: a = 5, b = 4, c = 4, d = 2

⇒ Tabelle fur P :

Zeichen Haufigkeit Indexd 2 3d 2 4b 4 2a 5 1

⇒ Vergleichsreihenfolge: d,d,b,a Indexreihenfolge: 3,4,2,1

j=1 Vergleiche P [3] mit T [3]⇒ Unterschied ⇒j=6 Vergleiche P [3] mit T [8]⇒ gleich ⇒

Vergleiche P [4] mit T [9]⇒ Unterschied ⇒j=9 Vergleiche P [3] mit T [11]⇒ Unterschied ⇒j=10 Vergleiche P [3] mit T [12]⇒ Unterschied ⇒j=14 Durchlauf beendet


⇒ Anstatt m ∗ (n − m) = 4 ∗ 11 = 44 wurden nur 5 Vergleiche benotigt!(z.B. 9 bei Quicksearch)

Bemerkung Bei Quicksearch und Optimal Mismatch ist auch die Verwendungder

”?“–Wildcards (1 beliebiges Zeichen) leicht realisierbar: Bei Vergleichen wer-

den”?“ einfach ignoriert (d.h. in der Tabelle fur Optimal Mismatch scheinen

sie einfach nicht auf, da sie ja ohnehin immer ubereinstimmen) und beim Be-rechnen des Shift-Wertes muß das rechteste Auftreten eines

”?“ im Suchstring

berucksichtigt werden, da ja nicht weiter verschoben werden darf.Fur den

”⋆“-Operator (beliebig viele Zeichen) hilft folgende Methode: Soll

S1 ⋆ S2 gefunden werden, so wird getrennt nach S1 und S2 gesucht, und dieErgebnisse werden entsprechend kombiniert.

Kapitel 14

Parallele Algorithmen


Der Entwurf von parallelen Algorithmen gewinnt in den letzten Jahren zuneh-mend an Bedeutung. Dies liegt zum einen in der begrenzten Moglichkeit, dieLeistungen einzelner Prozessoren zu steigern, zum anderen im Wunsch, kom-plexere Operationen direkt und schnell in Hardware auszufuhren. Daher richtetsich die Entwicklung paralleler Algorithmen auf zwei Ziele:

• Entwicklung fur Multiprozessorsysteme.Hier sind Algorithmen gefragt, die Aufgabenstellungen auf mehrere (un-abhangige) Universalprozessoren verteilen und somit das Problem schnel-ler losen, als es fur einen einzelnen Prozessor moglich ware.

• Entwicklung von Schaltkreisen.Hier sollen Algorithmen gefunden werden, die sich leicht durch Grund-gatter (z.B. Addition, logische Verknupfungen, . . . ) nachbilden lassen undsomit eine direkte, schnelle Hardwarelosung ermoglichen.

Da der Themenkomplex”paralleler Algorithmen“ sehr umfangreich und dyna-

misch ist, kann dieses Kapitel nur einen sehr kurzen und einfachen Einstiegin dieses Gebeit beinhalten. Die Parallelisierung sequentieller Algorithmen istnicht immer offensichtlich, oft auch unmoglich.

14.2 Wichtige Maße fur die Effizienz parallelerAlgorithmen

Fur ein Problem A sei

T (n) der Worst–Case Zeitbedarf des schnellsten sequentiellen AlgorithmusTp(n) der Worst–Case Zeitbedarf des zu bewertenden parallelen AlgorithmusP (n) die Anzahl benotigter Prozessoren (oder

”Gatter“) des zu bewertenden

parallelen Algorithmus

104 KAPITEL 14. PARALLELE ALGORITHMEN

Dann gilt:

Speed Up := T (n)Tp(n)

Kosten des parallelen Algorithmus := Tp(n) · P (n)

Effizienz des parallelen Algorithmus := T (n)Kosten = T (n)

Tp(n)·P (n)

Zum Vergleich: T (n) stellt praktisch die Kosten des sequentiellen Algorithmusdar.

Die Effizienz ist immer ≤ 1, sonst konnte man ein Mehrprozessorsystem

”simulieren“ und somit den sequentiellen Algorithmus beschleunigen. Ist alsoeine untere Schranke fur die Laufzeit des sequentiellen Algorithmus bekannt, soist dies auch eine untere Schranke fur die Kosten!!

14.3 Beispiele

14.3.1 Paralleles Berechnen von Prafixsummen

Gegeben sind n Integer–Zahlen x1, . . . , xn, n = 2k

Gesucht sind alle Prafixsummen, also

Sj =

j∑i=1

xi, 1 ≤ j ≤ n

Es soll ein Schaltkreis nach folgendem Modell entwickelt werden 1

• Es stehen Gatter zum Addieren zweier Werte zur Verfugung.

• Unabhangige Operationen sind gleichzeitig moglich.

x x x1 2 n

S S S1 2 n

=gesucht

BlackboxFrage: In welcher Zeit konnenS1, . . . , Sn berechnet werden?Wieviele Gatter sind notwendig?

Bemerkung: Eine einfache”sequentielle“ Implementation wurde Θ(n) Zeit benotigen.


14.3 Beispiele 105

Idee: Teile die Berechnung in 3 Phasen:

1. Berechne (parallel!)y1 = x1 + x2

y2 = x3 + x4

. . .yn/2 = xn−1 + xn

2. Berechne nun (mit derselben Idee2) die Prafixsummen fur yi (R1 = y1, R2 =y1 + y2, . . . )

3. Berechne (parallel!) die Prafixsummen fur xi aus xi und Ri:S1 = x1

S2j = Rj j = 1..n2S2j+1 = Rj + x2j+1 = S2j + x2j+1

Beispiel n=8:

x x x x x x x x1 2 3 4 5 6 7 8

S S S S SSSS1 2 3 4 5 6 7 8

R 1 R 2

1Q

P1

Q2

R4R3

+

++

+ +

+

+

+

+

+

+

Analyse:Zeit:T (n) = 1 + T (n/2) + 1 = 2 + T (n/2), T (1) = 0⇒ T (n) = O(ld n)

2Beachte: Dies entspricht derselben uberlegung, die zur Rekursionen (rekursiver Aufruf)bei sequentiellen Algorithmen fuhrt!!!

106 KAPITEL 14. PARALLELE ALGORITHMEN

Anzahl Gatter:G(n) = n/2 +G(n/2) + n/2 = n+G(n/2) = n+ n/2 + n/4 + · · · ≤ 2n.

⇒ Die Berechnung der Prafixsummen kann mit maximal 2n Gattern in O(log n)Zeit durchgefuhrt werden.⇒ Speedup = O(n)/O(log n) = O(n/ log n); Kosten=O(n logn); Effizienz= O(1/ log n)

14.3.2 Parallele Addition von n Zahlen

Gerade bei Hardwareimplementationen kann durch wiederholtes Losen dersel-ben Aufgabenstellung eine Effizienzsteigerung erreicht werden, wenn die einzel-nen Gatter in unabhangigen Schichten angeordnet sind.

Beispiel: Parallele Addition von n Zahlen mittels Baumstruktur 3

+++

+

+

+

L1

L2

L3

x1 x2 x3 x4 x5 . . .

n

i=1x i

P (n) = θ(n)Tp(n) = θ(ld n)Kosten = P (n) · Tp(n) = O(n ld n)Effizienz = O( 1

ld n ]

Die einzelnen Schichten des Netzwerkes sind unabhangig, d.h. L2 berechnet z.B.die Summen der Teilergebnisse von L1, wahrend L1 bereits neue Teilsummenbildet. Auf diese Weise wird das Netzwerk optimal ausgelastet und es wird(nach einer Anlaufzeit von O(log n)) jeweils pro Schritt ein Ergebnis ausgegeben.(”Wellenberechnung“, systolische Struktur)

Die Effizienz fur eine Folge von Operationen ergibt sich somit als:

Effizienz∗ =n

1 · n= 1

und ist damit optimal.

Diese Methode kann oft eingesetzt werden, z.B. Matrizenmultiplikationen, FFT,Kryptographie ect.


Teil VI

Anhang

Anhang A

Ubungsbeispiele

Kapitel 1: Einleitung

(a) Scanline Prinzip: Gegeben ist ein aufsteigend sortiertes Feld A[1..n],A[i] ∈ ℜ. Entwerfen Sie einen moglichst effizienten Algorithmus, derentscheidet, ob A zwei verschiedene Zahlen x und y enthalt, fur diey = −7.3x + 1

2 gilt. Analysieren Sie ihren Algorithmus und zeigensie seine Korrektheit. Zeigen Sie eine untere Laufzeitschranke fur denWorstcase dieses Problems.

(b) Exponentation

i. Sie sollen xn, x ∈ R, n ∈ N+, mit moglichst wenigen Multipli-kationen berechnen. Beschreiben Sie dazu das in der Vorlesungbesprochene, auf der Binardarstellung von n beruhende, Verfah-ren, und geben Sie den Algorithmus an.

ii. Ermitteln Sie mit diesem Verfahren die Anzahl notwendiger Mul-tiplikationen zur Berechnung von x33.

iii. Modifizieren Sie nun obige Methode, sodaß es auf Basis 3 arbei-tet, d.h. n wird als Zahl zur Basis 3 dargestellt. Erklaren Sie diedazu notwendigen Anderungen und geben Sie den neuen Algo-rithmus an. Welche Laufzeit besitzt dieser Algorithmus?

iv. Wieviele Multiplikationen sind mit diesem modifizierten Ver-fahren zur Berechnung von x33 (x17) notwendig? (Hilfestellung:3310 = 10203)

(c) Gegeben ist eine naturliche Zahl x. Gesucht ist x15, erlaubte Opera-tionen sind Wertzuweisungen und Multiplikationen. Zeigen Sie, wieman x15 mit 6 Multiplikationen berechnen kann (leicht), und wie mandies auch mit nur 5 Multiplikationen schafft.

Kapitel 2: Rekursive Zeitgleichungen

(a) Ein Algorithmus A besitzt eine Laufzeit, die durch die RekursionT (n) = 7T (n/2) + n2 beschrieben wird. Ein Algorithmus A′ fur die-selbe Aufgabenstellung besitzt eine Laufzeit T ′(n) = aT ′(n/4) + n2.Geben sie den großtmoglichen Wert von a an, sodaß Algorithmus A′

asymptotisch schneller als A ist.

110 ANHANG A. UBUNGSBEISPIELE

(b) Losen Sie folgende Rekursion mittels Substitutionsmethode T (n) =2T (n2 ) + 1, T (1) = 1

Kapitel 3: Dynamisches Programmieren

(a) Gegeben sind 4 Matrizen der Große A1 = 20 × 10, A2 = 10 × 100,A3 = 100 × 5, A4 = 5 × 50. Berechnen Sie effizient die optimaleKlammerung zur Berechnung des Matrizenproduktes A1 ·A2 ·A3 ·A4

(wobei zur Multiplikation zweier Matrizen die Schulmethode verwen-det wird). Erklaren Sie kurz die verwendete Methode und geben Siealle Zwischenschritte an. Vergleichen Sie den Aufwand der optimalenLosung mit dem Aufwand ohne Klammerung.

(b) Entwerfen Sie einen Algorithmus der aus einer (unsortierten) Fol-ge von n Zahlen die langste monoton wachsende Teilfolge ermittelt.(Hinweis: Der Algorithmus darf maximal O(n2) Schritte benotigen.)

(c) Sei A[i, j] ein zweidimensionales Feld von positiven Gleitkommazah-len mit n Zeilen und 2n Spalten. Das Element A[1, 1] steht dabei“links oben”.

Eine Teilmenge S der Eintrage in A heißt Stiege, wenn (1) S ausjeder Zeile von A genau ein Element enthalt und (2) der Eintragaus Zeile i links vom Eintrag in Zeile i − 1 steht, 2 ≤ i ≤ n. Die Sentsprechenden Felder laufen also in A von der untersten zur oberstenZeile “stiegenformig” nach rechts. Siehe Bild:

1

1 2 8 9 103 4 5 6 7

2

3

4

5

Beispiel einer Stiege fur n=5. Die Elementevon S sind grau unterlegt.

Der Wert einer Stiege sei die Summe Ihrer Elemente. Gesucht ist dieStiege mit maximalem Wert. Entwerfen Sie einen Algorithmus, derdieses Problem effizient lost (in PseudoCode oder naturlicher Spra-che). Verwenden Sie dazu das Paradigma “Dynamisches Programmie-ren”. Erklaren Sie genau die Bedeutung des verwendeten Feldes undfuhren Sie eine Worstcase-Analyse fur die Laufzeit Ihres Algorithmusdurch.

111

Kapitel 4: Randomisierung

(a) Beweisen oder widerlegen Sie: Sind die Werte und Prioritaten desrandomisierten Suchbaumes paarweise verschieden (d.h. alle Wertebzw. Prioritaten sind verschieden), so ist der randomisierte Such-baum eindeutig.

Kapitel 5: Schnitt von Liniensegmenten

(a) Erklaren Sie, weshalb der einfache Schnitt-Detektor fur Kreisscheiben(Plane-sweep Technik) fur Kreise nicht korrekt funktioniert.

(b) Mit welcher einfachen Idee kann das fur Liniensegmente verwendeteVerfahren auch zur Berechnung aller Schnitte von Kreisen verwendetwerden? (Idee beschreiben, kein Programmcode!)

Kapitel 6: Optimale Triangulierungen

(a) Gegeben ist ein konvexes Polygon mit 2n Ecken. Gesucht ist die Auf-teilung des Polygons in konvexe Vierecke, sodaß die Gesamtlange derUmfange minimal wird. Entwerfen Sie einen moglichst effizienten Al-gorithmus fur dieses Problem und analysieren Sie seinen Zeit- undSpeicherbedarf.

Kapitel 7: Konvexe Hullen

(a) Zeigen Sie die Ω(n logn) untere Zeitschranke zur Berechnung derkonvexen Hulle von n Punkten in der Ebene.

(b) Geben Sie einen Algorithmus an, der fur die konvexe Hulle von nPunkten in der Ebene in linearer Zeit deren Weite berechnet. (Diekonvexe Hulle ist gegeben!)

(c) Gegeben ist eine Menge P von n Punkten in der Ebene. KonstruierenSie einen Algorithmus, der moglichst schnell eine Gerade G ermittelt,die den Abstand des von G am weitesten entfernten Punktes aus Pminimiert. Zeigen Sie die Korrektheit und analysieren sie die Zeit-komplexitat Ihrer Losung.

Kapitel 8: Einfache Graphen-Algorithmen

(a) Zeigen Sie, daß fur einen Baum stets m = n− 1 gilt.

(b) Beweisen Sie den Eulerschen Polyedersatz: n+ f = m+ 2.

(c) Sie haben ein E-Werk, ein Wasser-Werk und ein Gas-Werk sowiedrei Hauser. Zeigen oder widerlegen Sie: Es gibt eine kreuzungsfreieVerbindung von jedem dieser Hauser zu jedem Versorgungs-Werk.

(d) Zeigen Sie, daß der Graph K3,3 nicht planar ist.

(e) Beweisen oder widerlegen Sie:

i. Jeder planare Graph hat zumindest einen Knoten mit Grad ≤ 5.

ii. Jeder planare Graph mit n ≤ 11 Knoten hat zumindest einenKnoten mit Grad ≤ 4.

(f) Geben Sie einen effizienten Algorithmus fur die 6-Farbbarkeit einesplanaren Graphen an. (Hinweis: Benutzen Sie das Ergebnis der vor-hergehenden Aufgabe.)


(g) Geben Sie ein einfaches Kriterium an, ob eine ’Strichzeichnung’ (sieheBeispiele) mit nur einer durchgehenden Linie erstellt werden kann.

(h) Gegeben ist ein zusammenhangender Graph mit n Knoten und mKanten. Entwerfen Sie einen Algorithmus, der moglichst effizient fest-stellt, ob dieser Graph bipartit ist. Zeigen Sie die Korrektheit IhrerLosung, und analysieren Sie den Zeit- und Speicherbedarf.

(i) Suchen in Graphen

i. Geben Sie einen ungerichteten, ungewichteten, kreisfreien, zu-sammenhangenden Graphen mit 8 Knoten an, und kennzeich-nen Sie einen Startknoten, sodaß sowohl Breitensuche als auchTiefensuche alle Knoten in derselben Reihenfolge besuchen! (Da-bei soll die Reihenfolge der Sohne eines Knotens eindeutig fixiertsein).

ii. Wieviele solcher ungerichteten, ungewichteten, kreisfreien, zu-sammenhangenden Graphen mit n Knoten, von denen einer alsStartknoten gekennzeichnet ist, gibt es, sodaß sowohl Breiten-suche als auch Tiefensuche alle Knoten in derselben Reihenfolgebesuchen? Beweisen Sie Ihre Aussage!

(j) Gegeben ist ein Graph G = (V,E) mit n =| V | Knoten und m =| E |Kanten. Zeigen Sie, daß es keinen Algorithmus mit Laufzeit O(nm)geben kann, der alle Kreise der Lange 4 in G auflistet.

Kapitel 9: Minimale Spannbaume

(a) Zur Konstruktion des MSB eines Graphen G wurden in der Vorlesungzwei Algorithmen besprochen. Erklaren Sie die Idee zur Auswahl “gu-ter” Kanten, die beiden Algorithmen zugrundeliegt, und beweisen Siedie Korrektheit dieser Idee.

(b) Sie haben eine Menge S von n Punkten im IR5 gegeben, sowie eineFunktion d(x, y), die in konstanter Zeit fur zwei Punkte x, y ∈ Sderen Abstand berechnet. Gesucht ist der MSB fur S.

Wahlen Sie das fur dieses Problem besser geeignete Verfahren, undbegrunden Sie Ihre Wahl, oder zeigen Sie, daß beide Verfahren gleichgut geeignet sind.

(c) Gegeben ist ein kantengewichteter Graph G = (V,E). Die Gewichtesind ganzzahlig, konnen aber auch negativ sein! Gesucht ist eine kreis-lose Kantenteilmenge E′ ⊆ E (d.h. ein kreisloser Teilgraph (V,E′)),

113

die ein moglichst großes Gesamtgewicht hat. Erklaren Sie, wie einesolche optimale Losung aussieht, und in welcher Zeit sie berechnetwerden kann. Hinweis: Sie konnen dazu gegebenenfalls in der Vorle-sung verwendete Algorithmen als Unterprogramm aufrufen.

Kapitel 10: Kurzeste Wege in Graphen

(a) Beschreiben Sie kurz den Algorithmus von Dijkstra zur Berechnungder kurzesten Wege in gewichteten, zusammenhangenden GraphenG = (V,E).

i. Wie verhalt sich der Algorithmus, wenn auch negative Kanten-gewichte erlaubt sind? Beweisen Sie entweder seine Korrektheit,oder geben Sie ein Gegenbeispiel an.

ii. Welche Modifizierungen mussen am Algorithmus vorgenommenwerden, wenn das Gewicht eines Pfades nicht die Summe, son-dern das Produkt seiner Kantengewichte darstellt? Dabei gilt,daß das Gewicht einer Kante immer > 1 ist. Beweisen Sie IhreAussage!

(b) Der Durchmesser d(G) eines ungewichteten zusammenhangenden Gra-phen G ist der maximale Abstand zweier Knoten aus G: d(G) =maxu,v∈G d(u, v), mit d(u, v) ist die Lange (=Anzahl Kanten) deskurzesten Weges von u nach v.

Folgender Algorithmus berechnet den Durchmesser d(B) fur den Spe-ziallfall eines Baumes B: Nimm einen beliebigen Knoten x ∈ B. Be-stimme einen Knoten y ∈ B der von x maximalen Abstand hat.Bestimme einen Knoten z ∈ B der von y maximalen Abstand hat.Dann ist der Abstand von y nach z der Durchmesser des Baumes.

Zeigen Sie die Korrektheit dieses Algorithmus’ (Hinweis: zeigen Siezuerst, daß y sicher Endpunkt eines Pfades maximaler Lange ist).

Kapitel 11-12: NP-vollstandige Probleme

(a) Zeigen oder widerlegen Sie: Das Problem ’Hamiltonscher Kreis’ istauch fur gerichtete Graphen NP-vollstandig.

(b) TSP

i. Zeigen Sie: In einem konvexen Viereck ist die Gesamtlange derbeiden Diagonalen immer großer der Gesamtlange zweier einan-der gegenuberliegender Seiten.

ii. Zeigen Sie: Die optimale Rundreise (TSP) fur eine ebene Punkt-menge in allgemeiner Lage kreuzt sich nicht selbst.

iii. Entwerfen Sie einen moglichst schnellen Algorithmus fur das TSPauf konvexen ebenen Punktmengen (d.h. alle Punkte liegen aufder KH der Punktmenge).

Hinweis: Die Aufgaben (i) bis (iii) sind bewußt in dieser Reihenfolgeangegeben!

(c) Kreuzen Sie korrekte Aussagen an.

⃝ Jedes NP-vollstandige Problem A ist auf jedes NP-vollstandigeProblem A′ polynomial reduzierbar.


⃝ NP-vollstandige Probleme sind die schwersten Probleme aller Pro-bleme in NP.⃝ NP steht fur ’nondeterministic-polynomial’.⃝ Ist ein Entscheidungsproblem NP-vollstandig, dann auch das zu-gehorige Optimierungsproblem.⃝ Kann ein Optimierungsproblem in polynomialer Zeit gelost wer-den, dann auch das zugehorige Entscheidungsproblem.⃝ Die Berechnung der Konvexen Hulle von n Punkten in der Ebeneist in NP.⃝ 2SAT und 3SAT sind beide in NP.⃝ Alle wohlformulierten Probleme sind entweder in P oder in NP.⃝ Fur NP-vollstandige Probleme gibt es eine exponentielle untereLaufzeitschranke.⃝ Beim Reduktionsbeweis wird das zu klassifizierende Problem aufein bereits als NP-vollstandig bekanntes Problem reduziert.

Kapitel 13: String-Matching Verfahren

(a) Erklaren Sie die beiden Stringsuch-Methoden a) Knuth-Morris-Prattsowie b) Quicksearch. Erlautern Sie insbesonders den Unterschied derverwendeten Verschiebefunktionen.

(b) Erlautern Sie Vor- und Nachteile der beiden Verfahren, wenn Sie ineinem Text auf einem sequentiellen Datentrager (z.B. Magnetband)suchen. Welches Verfahren ist dafur besser geeignet?

(c) Geben Sie einen Pseudocode fur das Verfahren Optimal Mismatchan, welches die Verwendung des Wildcards ’?’ (ein beliebiges Zei-chen) erlaubt. Erlautern Sie, welche negativen Auswirkungen dieseErweiterung auf die Laufzeit haben kann.

Kapitel 14: Parallele Algorithmen

(a) Geben Sie verschiedene Schaltungsmoglichkeiten fur n = 2k Prozes-soren an, wenn Sie folgende Probleme losen wollen:

i. Numerische Gittersimulationen in 2D (Finite Elemente ...)

ii. Numerische Gittersimulationen in 3D (Wettervorhersage ...)

iii. Universelle Schaltung, sodaß die Anzahl notwendiger Verbin-dungsanschlusse pro Prozessor klein gehalten wird, der maxi-male Kommunikationsabstand zweier Prozessoren (= Lange derkurzesten Verbindung zwischen zwei Prozessoren) jedoch log2 nnicht uberschreitet.

(b) Zeigen oder widerlegen Sie: Es gibt einen parallelen Algorithmus mitΘ(√n) Prozessoren, der in O(

√n) Zeit die konvexe Hulle fur n Punk-

te in der Ebene berechnet.

(c) Konstruieren Sie einen parallelen Algorithmus, der mit Θ(√n) Pro-

zessoren (Ver-gleichsgattern) das Minimum von n Zahlen (unsortiert)in O(

√n) Zeit bestimmt.

(d) (Parallele Algorithmen) Erklaren Sie die in der Vorlesung bespro-chene Schaltung zur parallelen Berechnung der Prafixsummen vonn Integer Zahlen (n = 2k). Welche Erweiterungen mussen an der

115

Schaltung vorgenommen werden, damit eine Folge von solchen Be-rechnungen effizient durchgefuhrt werden kann (Wellenberechnung!)?Gefordert ist, daß nach der Anlaufzeit pro Takt ein Ergebnis gelie-fert wird. Geben Sie die Schaltung und insbesondere den Bedarf anGattern an.

Index

K3,3,K5, 69Π-Verschiebefunktion, 96Ubungsbeispiele, 19, 52, 54, 64, 70, 80,

1092SAT, 883SAT, 884–Farbensatz, 67

Abstand in Graphen, 64Addition, parallele, 106Adjazenz–Liste, 65Adjazenz–Matrix, 65Algorithmus

Approx–Maxsum, 92Naherungen, 89parallel, 103von Dijkstra, 77von Floyd–Warshall, 79von Graham, 47von Karp–Rabin, 98von Knuth–Morris–Pratt, 97von Kruskal, 75von Prim, 73

AnalysePotentialmethode, 48, 97, 98randomisierte, 33, 50

animierter Algorithmus, 10, 25, 31, 40,47, 49, 55, 57, 71, 73, 77, 78,97, 104, 106

animierter Algortihmus, 40Approx–Maxsum–Algorithmus, 92Approximationsschema, 90azyklischer Graph, 64

Baum, 64BFS, 66binarsortierte Suchbaume, 31Bipartite Graphen, 67Boyer–Moore, 100Breitensuche, 66

Catalan–Zahlen, 26, 56

chromatische Zahl, 67

dunne Graphen, 65Delaunay–Triangulierung, 55, 76DFS, 68dichte Graphen, 65Dijkstra–Algorithmus, 77Direktberechnung der Distanzmatrix,

79Distanzmatrix, 66, 77, 79Divide & Conquer, 13, 58Dynamisches Programmieren, 23

Floyd-Warshall Algorithmus, 79lgT, 28Matrizenmultiplikation, 26optimale Triangulierung, 58

Einfache Graphen–Algorithmen, 63Einzelproblem, 84Entscheidungsproblem, 84Eulerscher Polyedersatz, 70Exponentation, 15

Fibonacci–Zahlen, 23, 24Floyd–Warshall Algorithmus, 79Formula Satisfiability, 88

geometrische Rundreise, 84, 87approximativ, 90

gerichteter Graph, 63gewichteter Graph, 63Grad eines Knotens, 64Graham–Scan, 47Graphen, 63

Algorithmen, 63Grundbegriffe, 63Speichern, 65Suchen, 65

Graphisomorphismus, 69Greedy–Algorithmus, 72gute Kanten in Graphen, 72

INDEX 117

Halde, 31, 41, 74Hamiltonscher Kreis, 85, 88harmonische Zahlen, 35, 51Hauptreihenfolge, 65Heuristik, 89

In–Valenz, 64Index, 116Iterative–Methode, 20iteratives Einfugen, 49

k–farbbar, 67kurzeste Wege in Graphen, 77Karp–Rabin–Algorithmus, 98KH, 45KMP-Algorithmus, 97Knuth–Morris–Pratt–Algorithmus (KMP),

97konvexe Hullen, 45

3D, 49Anwendungen, 45Graham–Scan, 47iteratives Einfugen, 49

Kreis im Graph, 63Kruskal–Algorithmus, 75Kuratowski-Graphen, 69

langste gemeinsame Teilfolge (lgT), 27Las Vegas–Methode, 99lgT, 27Liniensegmente, Schnitt von, 39

Master–Methode, 21Matrizen–Ketten–Multiplikation, 25Matrizen–Multiplikation, 16

Ketten-Multiplikation, 25Strassen–Methode, 16

Minimale Spannbaume (MSB), 71Monte–Carlo–Algorithmus, 99MSB, 71Multiplikation langer Zahlen, 13

Naherungsalgorithmen, 89Nebenreihenfolge, 65NP, 85NP-vollstandige Probleme, 83NP-vollstandigkeitsbeweis, 86, 87

Optimal–Mismatch, 100Optimierungsproblem, 84Out–Valenz, 64

output-sensitiv, 40

P, 85P verus NP, 86parallele Addition, 106parallele Algorithmen, 103

wichtige Kennwerte, 103parallele Prafixsummen, 104Pfad im Graph, 63plattbar, 69plan, 69planar, 69Planare Graphen, 69Plane–Sweep, 40, 47, 55Polygon, 53

konvex, 45, 53, 55Triangulierung, 53

polynomial reduzierbar, 86polynomiales Approximationsschema, 90Potentialmethode, 48, 97, 98Prafix, 28, 96Prafixsummen, 104Prim–Algorithmus, 73Prioritaten, 31, 73, 79

Balancierung nach, 31Problemklasse NP, 85Problemklasse P, 85Problemklassen, 84

Quicksearch, 100

randomisiertAnalyse, 33, 50Datenstruktur, 33Suchbaume, 31

Randomisierung, 31Reduktionsbeweis, 86regularer Graph, 64Rekursion, 23, 105

Interative–Methode, 20Master–Methode, 21Matrizenzerlegung, 25Substitutions–Methode, 20Teilbaume, 32, 56Triangulierung, 57versus dynamisches Programmie-

ren, 23Zeitgleichungen, 19

Rekursive Zeitgleichungen, 19relativer Fehler, 89

118 INDEX

RR, 87Rucksackproblem, 91

Approximation, 91Rundreiseproblem(RR), 87

SAT, 88Satz von Kuratowski, 69Scan–Line, 10, 12, 40, 47, 55Schnitt in Graphen, 72Schnitt von Liniensegmenten, 39

Naiver Algorithmus, 40Plane–Sweep Algorithmus, 40

Speichern von Graphen, 65SR, 31Stichwortindex, 116Strassen–Methode, 16String–Matching, 95

nach Karp–Rabin, 98nach Knuth–Morris–Pratt(KMP),

97Naiver Algorithmus, 95Optimal Mismatch, 100Quicksearch, 100Verfahren in der Praxis, 100

Substitutions–Methode, 20Suchbaume, 31Suchen

in die Breite, 66in die Tiefe, 68in Graphen, 65

Suffix, 96symmetrische Reihenfolge, 31

Teilfolge, langste gemeinsame, 27Teilgraph, 64Teilsumme, 10Teilsummenproblem, 10Textverarbeitung, 95Tiefensuche, 68Traveling Salesman Problem, 87Triangulierung, 53

Ubersicht, 55Algorithmus, 57allgemeiner Punktmenge, 54Anzahl im konvexen Polygon, 55Delaunay, 55, 76konvexes Polygon, 53, 54, 86optimale, 53, 54, 90simples Polygon, 54, 60

TSP, 84, 87

ungerichteter Graph, 63Union–Find Struktur, 75Urnenmodell, 35

Valenz, 64Verschiebefunktion, 96Vier–Farbensatz, 67voll polynomiales Approximationssche-

ma, 90vollstandiger Graph, 64

Worterbuchproblem, 31Wald, 64

Zeitgleichungen, 19Zufall, 31, 33, 34, 50, 101zusammenhangender Graph, 64

Documents

Entwurf & Analyse von Algorithmen · 2019-09-23 · Kapitel 1 Einleitung & Beispiele 1.1 Allgemeine Bemerkungen ” Entwurf & Analyse von Algorithmen“ hat die Entwicklung ” hochqualitativer“