Datenstrukturen und Algorithmen

Transkript

1 Datenstrukturen und Algorithmen Musterlösung zu Hausübungsblatt Daniel Warner 8. Mai 007 Aufgabe 5 Nachfolgend ist der Algorithmus Merge-Sort im Pseudocode dargestellt []. Merge-Sort(A, p, r) 1 if p < r then q (p+r) 3 Merge-Sort(A,p,q) 4 Merge-Sort(A,q + 1,r) 5 Merge(A,p,q,r) Es sei A ein beliebiges Array der Länge n = r p + 1. Der erste rekursive Aufruf von Merge-Sort operiert auf einem Array der Länge q p + 1 = p + r p + 1 = p + r p + 1 = r p = n + 1 = n. Der zweite rekursive Aufruf von Merge-Sort operiert auf einem Array der Länge n (q p + 1) = n n = n. dwarner@uni-paderborn.de

2 Damit ergibt sich, mit dem Wissen über die worst-case-laufzeit von Merge, die folgende Rekurrenzgleichung für die worst-case-laufzeit von Merge-Sort für beliebiges n N, n : T(n) = T ( n ) n + T( ) + cn Es gelte außerdem T(1) = 1. Wir vermuten T(n) dn log n = O(n log n) und beweisen unsere Vermutung durch vollständige Induktion nach n. Dabei ist d R >0 eine geeignete Konstante, die erst im Laufe des Beweises konkret bestimmt wird. Zur Induktionsvoraussetzung: Es sei n und T(n ) dn log n gelte für alle n < n. Zum Induktionsschritt: ( n ) n T(n) = T + T( ) + cn d n n n n log + d log + cn (I.V.) ( n n ) d + log n + cn = dn log n + cn < dn log n cn (n ) dn log 3 4 n + cn = dn (log 3 ) 4 + log n + cn ( = dn log n + c + d log 3 ) n 4 dn log n Die letzte Ungleichung ist erfüllt, falls d c. Damit ist der Induktionsschritt gezeigt. log 4 3 Es fehlt nun noch der Induktionsanfang: Aufgrund der Definition des O-Kalküls genügt es den Induktionsanfang für n = und n = 3 zu zeigen. Für n = erhalten wir ( ) T() = T + T( ) + c = T(1) + c = c +! d log = d, und für n = 3 erhalten wir ( 3 ) 3 T(3) = T + T( ) + 3c = T() + T(1) + 3c = 5c + 3! 3d log 3. Die beiden mit! gekennzeichneten Ungleichungen gelten, falls d c + 1 und d 5c+3 3 log 3, 5c+3 also setzen wir d auf das Maximum von c + 1, 3 log 3 und c. Damit ist der Beweis log 4 3 vollständig, und es gilt T(n) dn log n = O(n log n). Es gilt bekanntlich sogar T(n) = Θ(n log n). Um dies zu beweisen, zeigt man analog mit der Substitutionsmethode, dass auch die untere Schranke T(n) = Ω(n log n) gilt.

3 Aufgabe 6 Wir lösen die durch T(n) = { 3T( n ) + cn, falls n > 1 d, sonst definierte Rekurrenzgleichung durch Anwenden der Iterationsmethode. Dazu setzen wir T(n) iterativ in sich selbst ein und versuchen nach einigen Iterationen eine allgemeine Formel für die k.te Iteration aufzustellen: 1. Iteration T(n) = 3T ) + cn. Iteration = 3 ( 3T ) + c n ) + cn = 3 T ) + 3c n + cn 3. Iteration = 3 ( 3T 3 ) + c n ) + 3c n + cn = 3 3 T 3 ) + 3 c n + 3c n + cn. Nach diesen Iterationsschritten haben wir Anlass zur Behauptung, dass ) k 1 T(n) = 3 k T k + 3 i c n i für alle k N mit k log n gilt. 1 Wir beweisen die Korrektheit der geschlossenen Formel für T(n) durch vollständige Induktion: Der Induktionsanfang entspricht der 1. Iteration. Die Behauptung sei nun korrekt für k 1 N mit k log n. Dann gilt: ) k T(n) = 3 k 1 T (I.V.) k i c n i = 3 k 1( 3T ) n ) k + c k k i c n i = 3 k T ) + 3 k 1 k c n k k i c n i = 3 k T ( k 1 n ) + k 3 i c n i Damit ist auch der Induktionsschritt gezeigt, und mit dem Prinzip der vollständigen Induktion folgt die Behauptung. Die Iteration bricht bei T(1) ab, d.h. wenn n = 1 gilt. Das gilt aber genau dann, wenn k k = log n. Wir formen nun die geschlossene Formel für T(n) unter Verwendung der 1 Wir nehmen ohne Einschränkung an, dass n eine Zweierpotenz ist. 3

4 endlichen geometrischen Reihe für k = log n um: Wir erhalten also insgesamt ) k 1 T(n) = 3 k T k + 3 i c n i log(n) 1 = 3 log n T(1) + 3 i c n i = dn log 3 + cn log(n) 1 ( 3 ) i 3 ) log n = dn log cn( 3 1 = dn log 3 + cn nlog = dn log 3 + cnn log 3 cn = dn log 3 + cn log( 3 )+1 cn = dn log 3 + cn log( 3 )+log cn = dn log 3 + cn log 3 cn = (c + d)n log 3 cn = Θ(n log 3 ) T(n) = Θ(n log 3 ). Wir zeigen nun die Korrektheit des Algorithmus. Es sei n = k. Wir führen Induktion nach k. Der Induktionsanfang k = 0 ist klar: Der Algorithmus multipliziert zwei Bits stets korrekt. Als Induktionsvoraussetzung nehmen wir an, dass der Algorithmus auf allen Integern der Länge k 1 = n korrekt arbeitet. Zum Induktionsschritt: Der Algorithmus erhält als Eingabe zwei n-bit Integer X und Y. Diese werden in einen höherwertigen und einen niederwertigen Teil der Länge jeweils n aufgeteilt, sodass X = n A + B und Y = n C + D. Nach Induktionsvoraussetzung werden die Produkte BD, AC und (A + B)(C + D) korrekt berechnet. Einfaches Nachrechnen zeigt, dass BD + n ((A + B)(C + D) AC BD) + n AC = A + B)( n C + D) = XY gilt, womit auch der Induktionsschritt gezeigt ist. Damit folgt die Korrektheit des Algorithmus. Aufgabe 7a Wir lösen die durch T(n) { 9T( n 3 ) + 9n3, falls n > 1 = c, sonst 4

5 definierte Rekurrenzgleichung durch Anwenden der Iterationsmethode. Dazu setzen wir T(n) iterativ in sich selbst ein und versuchen nach einigen Iterationen eine allgemeine Formel für die k.te Iteration aufzustellen: 1. Iteration T(n) 9T 3 ) + 9n3. Iteration 9 ( 9T ) )3) + 9n 3 = 9 T ) + 9 n 3 + 9n Iteration 9 ( 9T ) + 9 ) 3) + 9 n 3 + 9n = 9 3 T ) + 93 n n 3 + 9n (3 3 ) 3 3. Nach diesen Iterationsschritten haben wir Anlass zur Behauptung, dass ) T(n) 9 k T 3 k + k 9 i n3 33(i 1) i=1 für alle k N mit k log 3 n gilt. Wir beweisen die Korrektheit der geschlossenen Formel für T(n) durch vollständige Induktion: Der Induktionsanfang entspricht der 1. Iteration. Die Behauptung sei nun korrekt für k 1 N mit k log 3 n. Dann gilt: T(n) ) k 1 9 k 1 T (I.V.) 3 k 1 + i=1 9 i n3 33(i 1) 9 k 1( 9T ) ) ) k k 3 k 1 + ) = 9 k T 3 k + 9 k ) k k 1 ) = 9 k T 3 k + k 9 i n3 33(i 1) i=1 i=1 i=1 9 i n3 33(i 1) 9 i n3 33(i 1) Damit ist auch der Induktionsschritt gezeigt, und mit dem Prinzip der vollständigen Induktion folgt die Behauptung. Die Iteration bricht bei T(1) ab, d.h. wenn n = 1 gilt. Das gilt aber genau dann, wenn 3 k k = log 3 n. Wir formen nun die geschlossene Formel für T(n) unter Verwendung der Wir nehmen ohne Einschränkung an, dass n eine Dreierpotenz ist. 5

6 unendlichen geometrischen Reihe für k = log 3 n um: T(n) 9 log 3 n T(1) + log 3 n i=1 log 3 n = cn log n 3 cn + 9n 3 i=1 = cn + 9n = cn + 7 n3 = O(n 3 ) ( 1 3) i 9 i n3 33(i 1) ( ) i 1 Wir erhalten also insgesamt T(n) = O(n 3 ). Aufgabe 7b Die Laufzeit T(n) eines Algorithmus A sei gegeben durch die Rekurrenzgleichung 3 T(n) = { 7T( n ) + n, falls n > 1 1, sonst, und die Laufzeit S(n) eines Algorithmus B sei gegeben durch die Rekurrenzgleichung S(n) = { as( n 4 ) + n, falls n > 1 1, sonst mit a N. Wir zeigen zwei unterschiedliche Herangehensweisen zur Lösung der Aufgabenstellung: Bei der ersten Variante gehen wir elementar vor, bei der zweiten Variante wenden wir das Master-Theorem an. Es zeigt sich im Vergleich der beiden Ansätze deutlich, dass die Verwendung des Master-Theorems einem in dieser Situation viel Arbeit abnimmt (die dafür aber in den Beweis des Master-Theorems investiert wurde). Bei beiden Beweisvarianten benutzen wir das folgende Lemma: Lemma 1. Es seien s 1 : N N und s : N N Funktionen, und es gelte s 1 o(s ). Dann gilt O(s 1 ) o(s ). 3 Dies ist gerade die Rekurrenzgleichung, die sich bei der Laufzeitanalyse des Matrixmultiplikationsalgorithmus von Strassen ergibt. 6

7 Beweis. Nach Voraussetzung gilt Es sei nun f O(s 1 ) beliebig. Dann gilt c > 0 n 0 N n n 0 : s 1 (n) c s (n). c 1 > 0 n 1 N n n 1 : f(n) c 1 s 1 (n). Es sei c > 0 beliebig. Setze c = c c 1. Dann gilt c > 0, und es folgt n 0 N n n 0 : c 1 s 1 (n) c 1 c s (n) = cs (n). Mit f O(s 1 ) und n := max(n 0, n 1 ) erhalten wir schließlich und damit f o(s ). n n : f(n) c 1 s 1 (n) cs (n) Anschaulich: Wenn die Funktion s 1 (asymptotisch) langsamer als s wächst, dann wächst jede Funktion f : N N, die höchstens so schnell wächst wie s 1, langsamer als s. Elementare Lösung Mit der Iterationsmethode und vollständiger Induktion erhalten wir für alle k log n und ) ) k 1 ( 7 i T(n) = 7T + n = 7 k T k + n 4) ) ) k 1 ( a i S(n) = as + n = a k S 4 4 k + n 16) für alle k log 4 n. Die Iteration bricht jeweils bei T(1) ab, d.h. wenn n n = 1 bzw. = 1 gilt. Das gilt k 4 k aber genau dann, wenn k = log n bzw. k = log 4 n. Unter Verwendung der endlichen geometrischen Reihe lassen sich T(n) und S(n) (für a 16) in eine geschlossene Form umformen: T(n) = 7 3 nlog n = Θ(n log 7 ) S(n) = a a 16 nlog 4 a a n 16 Um die asymptotische Laufzeit des Algorithmus B zu bestimmen, unterscheiden wir drei Fälle: 7

8 a<16: mit c 1 = Wir erhalten a a 16 0 und c = a Wegen lim n n n log 7 = lim n 1 n log 7 4 und wir erhalten S(n) = c 1 n log 4 a + c n 0. Daraus folgt Θ(n ) O(n ) S(n) = Θ(n ). = 0 gilt n o(n log 7 ). Mit Lemma 1 folgt o(n log 7 ), (Lemma 1) S(n) = o(n log 7 ), d.h. S(n) wächst asymptotisch langsamer als T(n) = Θ(n log 7 ). 4 Mit anderen Worten: Der Algorithmus B ist asymptotisch schneller als der Algorithmus A. a=16: Wir erhalten durch Einsetzen von a = 16 und k = log 4 n in die geschlossene Form von S(n): S(n) = 16 log 4 n + n log 4 n = n log n log 4 n = n + n log 4 n = Θ(n log n) Wegen lim n n log n n log 7 = 0 gilt n log n o(n log 7 ). Mit Lemma 1 folgt und wir erhalten Θ(n log n) O(n log n) S(n) = o(n log 7 ), o(n log 7 ), (Lemma 1) d.h. S(n) wächst asymptotisch langsamer als T(n) = Θ(n log 7 ). Mit anderen Worten: Der Algorithmus B ist asymptotisch schneller als der Algorithmus A. a>16: mit c 1 = Wir erhalten a a 16 1 und c = a S(n) = c 1 n log 4 a + c n 0. Daraus folgt S(n) = Θ(n log 4 a ). Es soll nun der größte Wert von a N bestimmt werden, für den der Algorithmus B asymptotisch schneller als der Algorithmus A ist. Mit den beiden bereits behandelten 4 Hier fließt ein, dass stets o(f) Ω(f) = gilt. 8

9 Fällen wissen wir, dass a 16 gelten muss. Weiterhin gilt n log 4 a = o(n log 7 ) n log 4 a lim n n log 7 = 0 lim n nlog 4 a log 7 = 0 log 4 a log 7 < 0 1 log a < log 7 log a < log 7 log a < log 7 = log 49 a < 49 Wir erhalten also, zusammen mit Lemma 1, dass O(n log 4 a ) o(n log 7 ) genau dann gilt, wenn a < 49. Somit ist der größte ganzzahlige Wert von a, für den S(n) asymptotisch langsamer wächst als T(n) = Θ(n log 7 ), gerade a = 48. Mit anderen Worten: Der größte ganzzahlige Wert von a, für den der Algorithmus B asymptotisch schneller ist als der Algorithmus A, ist a = 48. Verwendung des Master Theorems Die drei untersuchten Fälle a < 16, a = 16 und a > 16 entsprechen gerade genau den drei Fällen des Master-Theorems (vgl. [], S. 73), das wir nun statt der Iterationsmethode anwenden, um die Rekurrenzgleichungen T(n) und S(n) zu lösen. Offensichtlich gilt n = Ω(n log (7) ɛ 7 ) mit ɛ := log 4 > 0. Mit dem Master-Theorem erhalten wir sofort T(n) = Θ(n log 7 ). a<16: Es gilt n = Ω(n log 4 (a)+ɛ ) mit ɛ := log 4 16 a > 0. Des Weiteren gilt a 4 ) cn für fast alle n N und eine Konstante 0 < c < 1. Nach dem Master-Theorem gilt nun S(n) = Θ(n ). Genau wie bei der elementaren Lösung begründet man nun S(n) = o(n log 7 ). a=16: Es gilt offensichtlich n = Θ(n log 4 a ). Mit dem Master-Theorem folgt S(n) = Θ(n log n). Genau wie bei der elementaren Lösung zeigt man nun S(n) = o(n log 7 ). a>16: Es gilt n = Ω(n log 4 (a) ɛ a ) mit ɛ := log 4 16 > 0. Mit dem Master-Theorem folgt S(n) = Θ(n log 4 a ). Wie bei der elementaren Lösung beweist man nun, dass der größte ganzzahlige Wert von a, für den der Algorithmus B asymptotisch schneller ist als der Algorithmus A, gerade a = 48 ist. 9

10 Aufgabe 8 Wir verfolgen den folgenden rekursiven Ansatz, um n Scheiben von einem Startstapel auf einen Zielstapel unter Zuhilfenahme eines Hilfsstapels zu bewegen: 1. Bewege die n 1 kleinsten Scheiben vom Startstapel auf den Hilfsstapel.. Bewege die größte der n Scheiben vom Startstapel auf den Zielstapel. 3. Bewege die n 1 kleinsten Scheiben vom Hilfsstapel auf den Zielstapel. Wir gehen zunächst davon aus, dass dieser Ansatz immer eine korrekte Lösung liefert und analysieren die Komplexität. Es sei T(n) die minimale Anzahl Bewegungen, die notwendig sind, um n Scheiben von einem Stapel auf einen anderen Stapel (unter den vorgegebenen Regeln) zu transportieren. Dann benötigt Schritt 1 T(n 1) Bewegungen, Schritt eine Bewegung und Schritt 3 wiederum T(n 1) Bewegungen. Folglich können n Scheiben in (höchstens) T(n 1) + 1 Schritten bewegt werden, d.h. es gilt T(n) T(n 1) + 1 für n > 0. Damit sind T(n 1) + 1 Bewegungen hinreichend zur Lösung; wir müssen noch argumentieren, dass diese Anzahl Bewegungen auch notwendig ist [4]: Irgendwann muss die größte der n Scheiben auf den Zielstapel bewegt werden. Zu dem Zeitpunkt müssen die n 1 kleinsten Scheiben bereits auf einen einzigen anderen Stapel bewegt worden sein. Dies benötigt mindestens T(n 1) Bewegungen. Wir könnten die größte Scheibe mehr als einmal bewegen, aber nachdem wir die größte Scheibe das letzte mal bewegt haben, müssen wir die n 1 kleinsten Scheiben von ihrem Stapel auf die größte Scheibe transportieren. Dies benötigt wiederum mindestens T(n 1) Bewegungen. Also gilt T(n) T(n 1) + 1, und wir erhalten insgesamt T(n) = { T(n 1) + 1, falls n > 0 0, falls n = 0. Mit vollständiger Induktion zeigt man leicht, dass T(n) = n 1 für alle n 0 gilt. 5 Wir geben mit diesen Vorüberlegungen nun einen Algorithmus an, der das Problem Türme von Hanoi korrekt löst: Hanoi(n) 1 Hanoi-Recursive(n, A, B, C) 5 Interessanterweise ist n 1 gerade die n.te Mersenne sche Zahl. 10

11 Hanoi-Recursive(i, start, hilf, ziel) 1 if i > 0 then Hanoi-Recursive(i 1, start, ziel, hilf ) 3 Bewege die oberste Scheibe von start nach ziel. 4 Hanoi-Recursive(i 1, hilf, start, ziel) Mit dem Vorstehenden ist die Laufzeit des Algorithmus Hanoi Θ ). Zur Korrektheit: Wir zeigen per vollständiger Induktion nach n N 0, dass der Aufruf Hanoi-Recursive(n, a, b, c) eine korrekte Bewegungsfolge liefert, wann immer n Scheiben auf einem beliebigen Startstapel a liegen und zu einem beliebigen Zielstapel c a unter Zuhilfenahme eines Hilfsstapels b (b a und b c) transportiert werden sollen, wobei auf b und c, sofern sie nicht leer sind, nur Scheiben liegen, die größer sind als die größte der zu transportierenden n Scheiben. Für n = 0 ist die Aussage trivial und damit der Induktionsanfang erfüllt. Im Induktionsschritt schließen wir von n 1 auf n > 0. Nach Induktionsvoraussetzung bewegt der Aufruf Hanoi-Recursive(n 1, a, c, b) die oberen n 1 Scheiben korrekt von a nach b, denn die Rollen von b und c als Hilfs- bzw. Zielstapel können vertauscht werden. Die größte der n zu transportierenden Scheiben wird daraufhin auf den Stapel c transportiert, was zulässig ist, da c nach Voraussetzung entweder leer ist, oder auf c nur Scheiben liegen, die größer sind als die größte der n zu transportierenden Scheiben. Nun liegen auf dem Stapel a, sofern er nicht leer ist, nur Scheiben, die größer sind als die größte der n 1 nun zu verschiebenden Scheiben. Entsprechendes gilt für den Stapel c. Der anschließende Aufruf Hanoi-Recursive(n 1, b, a, c) bewegt also nach Induktionsvoraussetzung die n 1 obersten Scheiben korrekt vom Stapel b auf den Stapel c. Damit sind alle n Scheiben vom Startstapel a korrekt auf den Zielstapel c transportiert worden. Es folgt unmittelbar die Korrektheit des Algorithmus Hanoi. Die Türme von Hanoi sind ein Beispiel für ein praktisch unlösbares Problem: Die Anzahl Bewegungen, die notwendig und hinreichend ist, um n > 0 Scheiben von einem Stapel auf einen anderen Stapel zu bewegen ist T(n) = n 1; wir haben gesehen, dass sich dieses Ergebnis nicht verbessern lässt. Diese Anzahl ist aber exponentiell in der Anzahl n der Scheiben. Wie in Tabelle 1 ersichtlich, wird die Anzahl der Bewegungen selbst für kleine n astronomisch. Die in der Tabelle 1 angegebene Abschätzung für die benötigte Zeit, ergibt sich unter der Annahme, dass ein Mönch eine Scheibe pro Sekunde verschieben kann und bis zur Vollendung der Aufgabe ohne Unterbrechung arbeitet. Zieht man in Betracht, dass unser Universum etwa 13,5 Milliarden Jahre alt ist, so besteht also zunächst kein Anlass zu Weltuntergangsstimmung. 11

12 Anzahl Scheiben Minimale Anzahl Bewegungen Benötigte Zeit Sekunden Minuten Tage Jahre Jahrhunderte Milliarden Jahre Milliarden Jahre Tabelle 1: Praktische Unlösbarkeit der Türme von Hanoi [7] Aufgabe 9 Definitionen und Problemstellung Definition. Es seien p 1, p R d Punkte. Wir sagen, dass der Punkt p 1 = (x 1,..., x d ) den Punkt p = (x 1,..., x d ) dominiert, falls x k x k für alle k { 1,,..., d }. Im Falle des R heißt das für p 1 = (x 1, y 1 ) und p = (x, y ), dass x 1 x und y 1 y gilt. Es sei P R d eine Menge von Punkten. Ein Punkt m P heißt maximal (in P), falls er von keinem anderen Punkt aus P dominiert wird. Wir nennen die Menge M P der maximalen Punkten in P die Pareto-Menge von P. Abbildung 1 verdeutlicht die Begriffe Dominanz und Maximalität. Der Punkt p wird genau dann von einem Punkt p 1 dominiert, falls sich dieser rechts oberhalb (durch Schraffierung hervorgehoben) von p befindet. In der Abbildung wird p also von p 1 dominiert. Würde sich kein Punkt in der schraffierten Ebene befinden, so wäre p maximal. In diesem Beispiel ist p 1 ein maximaler Punkt, p hingegen nicht. y p 1 =(x 1,y 1 ) p =(x,y ) x Abbildung 1: Dominanz und Maximalität im R Gegeben sei nun eine endliche Menge P R. Wir wollen die Pareto-Menge von P berechnen. Dieses Problem ist auch bekannt als Maximum Vector Problem. 1

13 Algorithmus Der folgende Algorithmus ist ein Spezialfall des in [5, 6] vorgestellten Algorithmus, der in Zeit O(n(log n) d ) + O(n log n) die maximalen Punkte einer vorgegebenen endlichen Menge P R d berechnet. Im Falle des R ist die worst-case-laufzeit O(n log n) optimal. Beim Beweis der Optimalität argumentiert man über untere Schranken für bestimmte Sortierverfahren. Maximal-Points(P) Eingabe: Array P von Punkten mit x-koordinate P[k][1] und y-koordinate P[k][] Ausgabe: Die Pareto-Menge von P als Array 1 Sortiere P primär nach x-koordinate und sekundär nach y-koordinate, sodass P[1][1] P[][1]... P[length[P]][1] und P[j][] P[j + 1][] P[j + m][], falls P[i][1] = P[i + 1][1] für i { j, j + 1,..., j + m 1 }. return Maximal-Points-Recursive(P) Maximal-Points-Recursive(P) 1 if length[p] = 1 then return P 3 else P l P[1.. n ] 4 P r P[ n length[p]] 5 M l Maximal-Points-Recursive(P l ) 6 M r Maximal-Points-Recursive(P r ) 7 M Merge-Maximal-Points(M l, M r ) 8 return M Merge-Maximal-Points(M l, M r ) 1 n l length[m l ] n r length[m r ] 3 y max M r [1][] 4 for i to n r 5 do if M r [i][] > y max 6 then y max M r [i][] 7 M newarray(0) 8 for i 1 to n l 9 do if M l [i][] > y max 10 then length[m] length[m] M[length[M]] M l [i] 1 length[m] length[m] + n r 13 M[length[M] n r length[m]] M r 14 return M Erläuterung und Korrektheit Der Algorithmus Maximal-Points wird auf einer durch ein Array kodierten Punktmenge P R aufgerufen (vgl. Abbildung ). Diese wird primär nach der x-koordinate und sekundär nach der y-koordinate aufsteigend sortiert. Der 13

14 Sortiervorgang in Zeile 1 des Algorithmus Maximal-Points kann z.b. mit einem stabilen Sortieralgorithmus wie Merge-Sort durchgeführt werden, indem durch zwei hintereinander ausgeführte Aufrufe von Merge-Sort die Elemente des Arrays P zunächst nach der y-koordinate und dann nach der x-koordinate sortiert werden. Abbildung : Eine Punktmenge P R Nach dem Sortieren wird im Algorithmus Maximal-Points-Recursive rekursiv auf der Menge P operiert. Die Menge der Punkte P wird zunächst in eine linke Teilmenge P l und eine rechte Teilmenge P r annähernd gleicher Größe geteilt (vgl. Abbildung 3). P l P r Abbildung 3: Aufteilung der Punktmenge P in zwei Teilmengen P l und P r Für die beiden Mengen P l und P r werden rekursiv jeweils die Mengen M l und M r der maximalen Punkte berechnet. Die maximalen Punkte von P l bzw. P r sind in Abbildung 4 durch Linien miteinander verbunden. P l P r Abbildung 4: Rekursive Berechnung der maximalen Punktmengen M l und M r Anschließend werden die beiden Paretomengen M l und M r mit dem Algorithmus Merge-Maximal-Points zusammengefügt, und das Ergebnis M wird zurückgegeben. Dies ist offensichtlich ein Divide-&-Conquer-Ansatz. Der Rekursionsabbruch findet bei einer Menge, die aus genau einem Punkt besteht, statt. Die Menge der maximalen Punkte besteht dann trivialerweise genau aus diesem Punkt. Die meiste Arbeit steckt im Zusammenfügen der beiden maximalen Mengen M l und M r zu einer Menge M, die maximal für P sein soll: 14

15 Zunächst beobachtet man, dass kein Punkt p r = (x r, y r ) P r von einem Punkt p l = (x l, y l ) P l dominiert werden kann: Da das Array P primär nach x-koordinate und sekundär nach y-koordinate (aufsteigend) sortiert ist, gilt x l x r, und im Falle x l = x r gilt y l y r. Folglich wird p r nicht von p l dominiert. 6 Es kann aber sehr wohl Punkte in P r geben, die Punkte aus P l dominieren. Dabei genügt es, die Punkte in M l zu bestimmen, die von Punkten aus M r dominiert werden. Es sei m l = (x l, y l ) M l beliebig. Für alle Punkte m r = (x r, y r ) M r gilt dann x r x l. Der Punkt m l ist also in P genau dann maximal, wenn es keinen Punkt m r = (x r, y r ) M r mit y r y l gibt. Es genügt daher den Wert einer größten y-koordinate y max bzgl. aller Punkte aus M r zu berechnen und dann zu bestimmen, welche Punkte aus M l eine größere y-koordinate als y max besitzen. Genau diese Punkte aus M l sind maximal in P. Es gibt auch eine grafische Interpretation: Man zieht eine zur x-achse parallele Gerade durch die Punkte in M r mit der größten y-koordinate (vgl. Abbildung 5). P l P r Abbildung 5: Berechnung von y max Alle Punkte in M l, die sich auf oder unterhalb dieser Geraden befinden, sind nicht maximal in P. Die Punkte in M l oberhalb dieser Geraden sind hingegen maximal in P. Die for-schleife in Zeile 8 des Algorithmus Merge-Maximal-Points übernimmt gerade die Punkte aus M l, die maximal in P sind, in das Array M (vgl. Abbildung 6). P l P r Abbildung 6: Elimination von Punkten in M l, die von Punkten in M r dominiert werden Wir hatten zuvor beobachtet, dass kein Punkt aus P r von einem Punkt aus P l dominiert werden kann, d.h. alle Punkte in P r sind maximal in P. Daher werden diese in Zeile 13 des Algorithmus Merge-Maximal-Points am Ende des Arrays M angefügt. Insgesamt erhalten wir die Pareto-Menge M von P (vgl. Abbildung 7). Man bemerke außerdem, dass die Menge M wiederum primär nach x-koordinate und sekundär nach y-koordinate (aufsteigend) sortiert ist. 6 Für die Argumentation haben wir an dieser Stelle implizit vorausgesetzt, dass die Punkte im Array P paarweise verschieden sind. 15

16 Abbildung 7: Die Pareto-Menge M von P Laufzeitanalyse Es bezeichne T(n) die worst-case-laufzeit des Algorithmus Maximal- Points-Recursive. Dann gilt T(n) = T ) + cn = O(n log n) Die worst-case-laufzeit lässt sich noch verbessern, indem zur Verwaltung der maximalen Punkte ein balancierter binärer Suchbaum verwendet wird. Man erhält dann die Rekurrenzgleichung T(n) = T ) + c log n = O(n). Die worst-case-laufzeit des Algorithmus Maximal-Points ist aber in beiden Fällen O(n log n) aufgrund des vorab durchgeführten Sortiervorgangs. Anwendungen Das Maximum Vector Problem tritt in vielen unterschiedlichen Kontexten auf und ist als solches daher tiefgehend untersucht worden. Es hat neue Bedeutung durch sogenannte Skyline Queries (erstmals eingeführt in [1]) für relationale Datenbanken gewonnen. Bei Skyline Queries werden die maximalen Tupel über einer Menge von Tupeln gesucht. Bestimmte Spalten, deren zugrundeliegenden Domänen linear geordnet sind, werden als Skyline-Kriterien designiert. Dominanz wird dann bzgl. dieser Kriterien definiert. Die nicht-dominierten, d.h. maximalen Tupel formen dann die Skyline-Menge und somit das Ergebnis einer Skyline Query. Beispiel: Name Sterne Distanz Preis Aga ** Fol * Kaz * Neo *** Tor *** Uma ** Tabelle : Die Tabelle Hotel [3] Die folgende Skyline-Abfrage auf einer Tabelle Hotel, die die Spalten Name, Adresse, Sterne (Qualitätsmaß), Distanz (Distanz zum Strand) und Preis besitzt, fragt nach den Hotels, für die sich kein Hotel finden lässt, das zugleich mindestens genauso viele Sterne besitzt, mindestens genauso nah am Strand ist und mindestens genauso günstig ist: 16

17 SELECT Name, Adresse FROM Hotel SKYLINE OF Sterne MAX, Distanz MIN, Preis MIN; Das Resultat der Abfrage ist in der Tabelle fett hervorgehoben. Man kann die Daten aus Tabelle als Punkte im dreidimensionalen Raum visualisieren. Die Aufgabe besteht dann darin die maximalen Punkte zu bestimmen. Das entspricht gerade der Ergebnismenge der obigen Skyline-Abfrage. Aufgabe 10 Es sei G = (V, E) ein ungerichteter Graph mit V = { v 1,..., v n }. Gegeben sei weiterhin die Adjazenzmatrix A = (a ik ) { 0, 1 } n n von G, sodass gilt a ik = 1 { v i, v k } E Es sei r 1 beliebig. Setze A (r) := A r und sei A (r) = (a (r) ik ). Wir behaupten, dass dann die Anzahl der Wege der Länge (genau) r vom Knoten v i zum Knoten v k in G a (r) ik angibt. Dazu führen wir Induktion nach r. Der Induktionsanfang für r = 1 ist klar. Es sei nun r > 1 und die Behauptung korrekt für r 1. Seien i, k { 1,..., n }. Wir wollen die Anzahl der Wege der Länge r vom Knoten v i zum Knoten v k in G ermitteln. Dazu überlegt man sich, dass sich ein Weg der Länge r aus einem Weg der Länge r 1 und einer anschließenden Kante zusammensetzt. Es genügt also alle Kanten { v j, v k } E, die zum Knoten v k inzident sind, zu betrachten und die Anzahl der Wege von v i nach v j der Länge r 1 jeweils aufzusummieren, d.h. die Anzahl der Wege von v i nach v k der Länge r ist gegeben durch { v j,v k } E a (r 1) ij = n j=1 a (r 1) ij a jk = (A (r 1) A) ik = (A (r) ) ik. Damit ist auch der Induktionsschritt gezeigt und die Behauptung folgt mit dem Prinzip der vollständigen Induktion. Berücksichtigt man nun, dass Dreiecke in G Kreise der Länge 3, also Wege der Länge 3 mit gleichem Start- und Endknoten sind, so genügt es im Wesentlichen die Spur der Matrix D := A 3, d.h. die Summe der Diagonaleinträge von D zu berechnen. Da es innerhalb eines Dreiecks genau 6 Kreise der Länge 3 gibt, muss der so berechnete Wert anschließend noch durch 6 dividiert werden, um die Anzahl der Dreiecke in G zu bestimmen. Der nachfolgende Algorithmus Count-Triangles führt die beschriebene Idee aus. 17

18 Count-Triangles(A) Eingabe: n n-adjazenzmatrix kodiert als zweidimensionales Array A 1 D newarray(rows[a], rows[a]) D Strassen-Matrix-Multiplication(A, A) 3 D Strassen-Matrix-Multiplication(D, A) 4 s 0 5 for i 1 to rows[d] 6 do s s + D[i][i] 7 return s 6 Die Korrektheit des Algorithmus folgt mit den vorhergehenden Überlegungen. Die Laufzeit ist Θ(n log 7 ) wenn der Algorithmus von Strassen zur Matrixmultiplikation verwendet wird. Literatur [1] Börzsönyi, S. ; Kossmann, D. ; Stocker, K.: The Skyline Operator. In: 17th International Conference on Data Engineering (ICDE 01). Washington - Brussels - Tokyo : IEEE, April 001, S [] Cormen, Thomas H. ; Leiserson, Charles E. ; Rivest, Ronald L. ; Stein, Clifford: Introduction to Algorithms. Second Edition. MIT Press and McGraw-Hill Book Company, 001 [3] Godfrey, Parke ; Shipley, Ryan ; Gryz, Jarek: Algorithms and analyses for maximal vector computation. In: VLDB J 16 (007), Nr. 1, S. 5 8 [4] Graham, Ronald L. ; Knuth, Donald E. ; Patashnik, Oren: Concrete Mathematics. Second Edition. Reading, Massachusetts : Addison-Wesley, 1994 [5] Kung, H. T. ; Luccio, Fabrizio ; Preparata, Franco P.: On Finding the Maxima of a Set of Vectors. In: Journal of the ACM (1975), Nr. 4, S [6] Preparata, F. P. ; Shamos, M. I.: Computational Geometry: an Introduction. Berlin : Springer, 1985 [7] Wikipedia. Türme von Hanoi. URL: BCrme_von_Hanoi