Musterlösungen zu Datenstrukturen und Algorithmen SS 2005 Blatt 2, Aufgabe 3 Wir schreiben zunächst alle Funktionen zur Basis 2.

Transkript

1 Prof. Dr. Johannes Blömer Paderborn, den. August 005 Musterlösungen zu Datenstrukturen und Algorithmen SS 005 Blatt, Aufgabe 3 Wir schreiben zunächst alle Funktionen zur Basis. Dann erhalten wir 3 n log(n) = log(3)n log(n), n log(n) = log(n) /, n 10 = 10 log(n), 5 n/ = log(5)n/. Benutzten wir nun die Sätze.10 und.11 aus der Vorlesung so sehen wir, dass von den Funktionen im Exponenten log(3)n log(n) am schnellsten wächst. Dann kommt log(5)n/, dann log(n) / und schließlich 10 log(n). Damit wächst von den ursprünglichen Funktionen 3 n log(n) am schnellsten. Gefolgt von 5 n/, n log(n) und n 10, in dieser Reihenfolge. Blatt, Aufgabe 4. Diese Aussage ist falsch. Um dieses einzusehen, betrachten wir das Beispiel f(n) = n und g(n) = n/. Damit gilt dann f(n) = O(g(n)). Würden nun c, n 0 N existieren, so dass f(n) c g(n) für alle n n 0, so würde hieraus folgen, dass n/ c für alle n n 0. Dieses trifft sicherlich nicht zu. Blatt 3, Aufgabe 1(c) Hier sind zunächst die beiden Invarianten. Invariante Zeilen 3-5: Vor Durchlauf der Schleife mit Index j (und äußerem Index i) ist A[k] ein Minimum der im Teilarray A[i..j 1] gespeicherten Zahlen. Invariante Zeilen 1-6: Vor Durchlauf der Schleife mit Index i stehen in A[1..i 1] die i 1-kleinsten Eingabezahlen in aufsteigend sortierter Reihenfolge. Die restlichen Eingabezahlen stehen in A[i..length[A]]. Für beide Invarianten zeigen wir Initialisierung, Erhaltung und Terminierung. Dabei werden wir die Terminierung der Invariante für die Zeilen 3-5 benutzen, um die Erhaltung der Invariante in Zeilen 1-6 zu zeigen. Die Terminierung der Invariante in Zeilen 1-6 wird dann die Korrektheit des Algorithmus Selection-Sort beweisen. Initialisierung Invariante Zeilen 3-5: Vor dem ersten Durchlauf mit Index j = i + 1 ist k = i. Weiter ist A[i] sicherlich das Minimum der im Teilarray A[i..i] gespeicherten Zahlen. Erhaltung Invariante Zeilen 3-5: Angenommen die Invariante gilt vor Durchlauf der Schleife mit Index j. Dann ist also A[k] das Minimum der im Teilarray A[i..j 1] gespeicherten Zahlen. Nun wird aber in den Zeilen 4,5 dieses Minimum mit dem nächsten Element A[j] verglichen und im Fall A[j] < A[k] der Index k durch j ersetzt. Damit ist sicher gestellt, dass vor Durchlauf der Schleife mit Index j + 1 in A[k] das Minimum der Zahlen im Teilarray

2 A[i..j] gespeichert ist. Terminierung Invariante Zeilen 3-5: Am Ende der Schleife ist in A[k] das Minimum der Zahlen im Teilarray A[i..length(A)] gespeichert. Nun zur Invariante für Schleife in den Zeilen 1-6. Initialisierung Invariante Zeilen 1-6: Der erste Index ist i = 1. Vor dem Durchlauf mit diesem Index ist das Array A[1..i 1] leer. Die Aussage der Invariante ist damit korrekt. Erhaltung Invariante Zeilen 1-6: Angenommen die Invariante gilt vor Durchlauf der Schleife mit Index i. Damit stehen in A[1..i 1] die i 1-kleinsten Eingabezahlen in aufsteigend sortierter Reihenfolge. Die restlichen Eingabezahlen stehen in A[i..length[A]]. Nun wissen wir aber aus der Terminierung der Schleife in den Zeilen 3-5, dass in A[k] nun das Minimum der Zahlen im Array A[i..length[A]] gespeichert ist. Dieses wird nun in Zeile 6 mit dem Eintrag in Position i getauscht. Damit enthält vor Durchlauf mit Index i + 1 das Array A[1..i] die i-kleinsten Eingabezahlen in aufsteigend sortierter Reihenfolge. Außerdem stehen die restlichen Eingabezahlen im Teilarray A[i + 1..length(A)]. Terminierung Invariante Zeilen 1-6: Vor Durchlauf der Schleife mit Index length(a)+1 stehen nun die Eingabezahlen im Array A[1..length(A)], also des ganzen Arrays, aufsteigend sortiert in A[1..length(A)]. Damit ist Selection-Sort ein korrekter Sortieralgorithmus. Blatt 4, Aufgabe 3(a) Wie in der Aufgabe gefordert, führen wir einen Induktionsbeweis. Für n = 1, folgt die Korrektheit des Algorithmus sofort aus den Zeilen 1-4, insbesondere Zeilen 1 und. Dies ist der Induktionsanfang. Nun zum Induktionsschluss. Die Induktionsvoraussetzung ist, dass Stooge-Sort für alle Eingabegrößen m < n korrekt arbeitet. Nun wollen wir zeigen, dass Stooge-Sort auch für Eingabegröße n korrekt ist. Die Menge I j, j = 1,, 3 enthalte nun alle Eingabezahlen, die bei einer korrekten Sortierung im j-ten Drittel der sortierten Folge stehen. Wir zeigen für j = 1,, 3, dass Stooge-Sort die Zahlen in I j an die richtige Position bringt. Dabei können wir nach Induktionsvoraussetzung annehmen, dass jeder der rekursiven Aufrufe von Stooge-Sort in den Zeilen 6-8 eine korrekte Sortierung der entsprechenden Teilfolge liefert. Sie zunächst j = 1. Alle Elemente aus I 1 die zu Beginn im ersten oder zweiten Drittel von A stehen werden durch den Aufruf von Stooge-Sort in Zeile 6 in das erste Drittel verschoben. Durch den Aufruf von Stooge-Sort in Zeile 7 werden alle Elemente aus I 1, die zu Beginn im letzten Drittel von A standen in das zweite Drittel verschoben. Schließlich werden diese Elemente dann durch den letzten Aufruf von Stooge-Sort in Zeile 8 in das erste Drittel verschoben. Außerdem sind beim Aufruf von Stooge-Sort in Zeile 8 alle Elemente aus I 1 im ersten oder zweiten Drittel. Damit wird Stooge-Sort in Zeile 8 die Elemente aus I 1 nicht nur alle ins erste Drittel verschieben, sondern die Elemente aus I 1 werden auch in der richtigen Reihenfolge im ersten Drittel stehen. Für j =, 3 argumentiert man ähnlich. So stehen nach dem ersten Aufruf von Stooge-Sort in Zeile 6, alle Element aus I 3 im zweiten oder dritten Drittel. Diese werden dann durch den Aufruf von Stooge-Sort in Zeile 7 richtig sortiert in das letzte Drittel des Arrays A geschoben. Weiter stehen nach den ersten beiden Aufrufen von Stooge-Sort alle Elemente aus I in den ersten beiden Dritteln. Wie bei den Elementen aus I 1 werden diese Elemente dann durch den Aufruf von Stooge-Sort in Zeile 8 richtig sortiert in das zweite Drittel des Arrays A

3 geschoben. Blatt 4, Aufgabe 4 Es gilt T (n) 3T (n/) + n für n > 1. Gemäß der Rekursionsgleichung können wir T (n/) abschätzen durch 3T (n/4) + (n/). Damit erhalten wir T (n) 3(3T (n/4) + n /4) + n = 9T (n/4) + 3n /4 + n. Nun können wir T (n/4) abschätzen durch 3T (n/8) + (n/4) und erhalten T (n) 9(3T (n/8) + n /16) + n /4n = 7T (n/8) + 9n /16 + 3n /4 + n. Fahren wir so fort, erhalten wir für allgemeines i die Abschätzung i 1 T (n) 3 i T (n/ i ) + n (3/4) j. Nun nehmen wir zur Vereinfachung an, dass n eine Zweierpotenz ist. Dann ist log(n) eine natürliche Zahl. Setzen wir dann in der Abschätzung oben i = log(n), so erhalten wir Nun gilt T (1) = c. Außerdem gilt T (n) 3 log(n) T (1) + n j=0 log(n) 1 j=0 (3/4) j. log(n) 1 j=0 (3/4) j = 1 (3/4)log(n) 1/4 4, da es sich um eine geometrische Summe handelt. Da 3 log(n) = n log(3) < n folgt T (n) cn log(3) + 4n = O(n ). Blatt 5, Aufgabe Wir zeigen durch vollständige Induktion, dass für jedes beliebige a c die Abschätzung T (n) an 3 gilt. Für n = 1 ist Nichts zu zeigen. Nun zum Induktionsschluss. Induktionsvoraussetzung ist, dass T (k) ak 3 für alle k < n gilt. Wir wollen zeigen, dass T (n) an 3 für n. Wir betrachten nun für 1 k n 1 den Ausdruck T (k 1) + T (n k) + cn. sowohl auf T (k 1) als auch auf T (n k) können wir unsere Induktionsvoraussetzung anwenden. damit erhalten wir T (k 1) + T (n k) + n a(k 1) 3 + a(n k) 3 + cn. Nun benutzen wir, dass für alle s, t > 1 gilt (s + t) 3 s 3 + t 3. Damit ist Nun gilt für n a(k 1) 3 + a(n k) 3 + cn a(n 1) 3 + cn. a(n 1) 3 + cn = an 3 3an + 3an a + cn = an 3 an an + 3an a + cn an 3 4an + 3an an 3.

4 Wobei wir n und a c im Übergang von der. zur 3. Zeile ausgenutzt haben. Damit gilt T (n) max {T (k 1) + T (n k) + 1 k n 1 cn } an 3. Damit ist T (n) = O(n 3 ). Blatt 5, Aufgabe 4 Wir betrachten den folgenden Algorithmus General-Median, der den Algorithmus Median als Unteralgorithmus benutzt. General-Median(A, i): 1. Berechne mit Hilfe von Median den Median A[z] des Arrays A.. Partitioniere die Elemente des Arrays A um A[z] herum. 3. Falls i = n+1 n+1, Ausgabe A[z]. Falls i <, finde rekursiv den i-ten Median in den Einträgen < A[z]. Falls i > n+1 n+1 finde rekursiv den (i )-ten Median in den Einträgen > A[z]. Für den zweiten Schritt nehmen wir hierbei den Algorithmus Partition, den wir bei Quicksort kennen gelernt haben. Zunächst zeigen wir die Korrektheit von General-Median. Dabei gehen wir natürlich davon aus, dass der Algorithmus Median korrekt arbeitet. Damit ist das im ersten Schritt berechnete Element A[z] der Median des Eingabearrays A. Wir zeigen die Korrektheit nun mit vollständiger Induktion über die Länge n des Arrays. Ist n = 1, so wird im 3. Schritt immer A[1] ausgegeben. Dies ist für n, i = 1 auch die korrekte Antwort. Sei nun n. Als Induktionsvoraussetzung haben wir, dass für alle m < n und alle i, 1 i m der Algorithmus General-Median korrekt ist. Wir wollen zeigen, dass dann General- Median für alle Arrays der Größe n und alle 1 i n ebenfalls korrekt ist. Die Korrektheit für diese Fälle folgt nun aus den folgenden Beobachtungen: Ist i = n+1, so folgt die Korrektheit unmittelbar aus der Korrektheit von Median und der ersten Abfrage im 3. Schritt. Ist i < n+1, so ist der i-te Median von A der i-te Median des im. Schritt umsortierten Teilarrays A[1.. n+1 ]. Dies folgt unmittelbar aus der Definition des i-ten Medians. In diesem Fall folgt die Korrektheit von General-Median aus der Korrektheit von Median, der zweiten Abfrage im 3. Schritt und der Induktionsvoraussetzung. Ist i > n+1 n+1, so ist der i-te Median von A der i -te Median des im. Schritt umsortierten Teilarrays A[ n n]. Dieses gilt, denn alle Elemente im umsortierten Teilarray A[1.. n+1 ] sind dann auf jeden Fall kleiner als dieser Median. In diesem Fall folgt die Korrektheit von General-Median wiederum aus der Korrektheit von Median, der zweiten Abfrage im 3. Schritt und der Induktionsvoraussetzung. Nun noch die Laufzeitanalyse. Sei cn eine obere Schranke für die Laufzeit von Median bei einem Array der Länge n. Auch für Partition aus dem Abschnitt über Quicksort wissen wir, dass es lineare Laufzeit besitzt. Wir nehmen an, dass cn auch eine obere Schranke für die

5 Laufzeit von Partition bei einem Array der Größe n ist. Dann gilt für die Laufzeit T (n) von General-Median die folgende Rekursionsformel T (n) T (n/) + cn. Dabei haben wir zur Vereinfachung angenommen, dass n durch teilbar ist. Die Formel gilt, da im 3. Schritt der Algorithmus rekursiv entweder mit dem Array A[1.. n+1 ] 1] oder mir dem Array A[ n+1 ] + 1..n] aufgerufen wird. Beide Arrays habe Größe höchstens n/. Schließlich gilt T (1) = a für eine Konstante a. Damit erhalten wir für T (n) folgende Kette von Ungleichungen (wir nehmen zur Vereinfachung an, dass n eine Zweierpotenz ist): T (n) T (n/) + cn. T (n/4) + cn + cn T (n/8) + c/n + cn + cn log(n) 1 T (1) + cn (1/) i. i=0 Nun ist die Summe in der letzten Abschätzung eine geometrische Summe, die durch beschränkt ist. Außerdem war T (1) a für eine Konstante a. Damit ist T (n) = O(n). Blatt 6, Aufgabe a) Für den Algorithmus k-merge benutzen wir einen min-heap H, der immer genau k Elemente speichert. Jedes der sortierten Teilarrays T j, j = 1,..., k, erweitern wir um eine Dummyelement mit Wert. Der min-heap enthält zu jedem Zeitpunkt genau ein Element aus jedem der Teilarrays. Zu jedem Teilarray speichern wir noch einen Index n j, der zu Beginn für alle Teilarrays mit 1 initialisiert wird. Zu jedem Element im min-heap H speichern wir jeweils noch den Index j des Arrays, aus dem das Element stammt. Initialisiert wird der min-heap mit den ersten Elementen der Teilarrays. Dann wiederholen wir folgenden Schritte für i = 1,..., n. 1. Kopiere das minimale Element H[1] des min-heaps H in A[i].. Stammt H[1] aus dem Teilarray T j und ist n j = l, so ersetze H[1] durch T j [l + 1] und erhöhe n j um Benutze min-heapify(h, 1), um aus H wieder einen min-heap zu machen. Dabei ist min-heapify das Analogon von max-heapify für min-heaps. Mit diesem Algorithmus wird jeweils das i-kleinste Element der Eingabezahlen gefunden. Damit löst der so beschriebene Algorithmus unser Merge-Problem für k Teilarrays. Für jedes i müssen dabei zwei Elemente kopiert werden. Außerdem muss einmal min- Heapify aufgerufen werden. Da der Heap immer k Element besitzt, kostet jeder Aufruf von min-heapify Zeit O(log(k)) (wie bei max-heapify). Da außerdem die Initailisierung in Zeit O(k) erfolgen kann (durch Build-Min-Heap wie bei Build-Max-Heap), ist die Gesamtlaufzeit des oben beschriebenen Algorithmus O(log(k)n).

6 b) Für die Laufzeit T (k, n) von k-merge-sort bei einem Array der Größe n erhalten wird die folgende Rekursion T (k, n) kt (k, n/k) + c log(k)n. Dabei ist c eine Konstante, groß genug, um die Laufzeit von k-merge durch c log(k)n abschätzen zu können. Außerdem gilt T (k, 1) a, für eine Konstante a. Lösen wir nun die Rekursionsgleichung auf unsere übliche Art und nehmen wir zur Vereinfachung an, dass n eine Potenz von k ist, erhalten wir T (k, n) k log k (n) T (k, 1) + c log(k)n(log k (n) 1) an + cn log(n). Wir erhalten als Abschätzung für die Laufzeit T (n) = O(n log(n)). Blatt 7, Aufgabe Wir zeigen durch einen Widerspruchsbeweis, dass es einen solchen Algorithmus A nicht geben kann. Der Widerspruch wird dabei zur unteren Schranke von Ω(n log(n)) für Vergleichssortierer sein. Angenommen wir haben ein zu sortierendes Array B der Größe n. Um dieses mit Hilfe des angenommenen Algorithmus A zu sortieren, gehen wir folgendermaßen vor. 1. Mit Build-Max-Heap errichte auf B einen max-heap.. Lege ein Hilfsarray C der Größe n an. 3. Für i = n,..., 1 wiederhole folgende Aktion. Wende auf B den Algorithmus A an und schreibe das entfernte Element in C[i]. 4. Kopiere C nach A. Nach Annahme über A ist dieses ein korrekter Sortieralgorithmus. Er ist sogar ein Vergleichssortierer, da auch Build-Max-Heap nur die für einen Vergleichssortierer zulässigen Operationen benutzt. Schauen wir uns nun die Laufzeit dieses Vergleichssortierers an. Build-Max-Heap benötigt wie in der Vorlesung gezeigt Zeit O(n). Das Anlegen von C und das abschließende kopieren von C nach A benötigen ebenfalls Zeit O(n). Schließlich benötigen wir nach Annahmen über die Laufzeit von A auch für die Schleife im 3. Schritt des Algorithmus insgesamt nur Zeit O(n), für jedes i nämlich Zeit O(1). Damit haben wir mit Hilfe von A einen Vergleichssortierer mit Laufzeit O(n) konstruiert. Da es einen solchen Algorithmus aufgrund der unteren Schranke von Ω(n log(n)) für die Laufzeit von Vergleichssortierern nicht gibt, kann ein Algorithmus A mit den in der Aufgabe beschriebenen Eigenschaften nicht existieren. Blatt 8, Aufgabe 1 Man kann z.b. die folgende Lösung verwenden. Ein leerer Stack S wird als eine leeren Queue Q initialisiert. Eine Push-Operation des Stacks wird an ein Enqueue-Operation der Queue delegiert, d.h.: push(s, x): 1 enqueue(q, x)

7 Da die Queue-Operationen Laufzeit O(1) haben, hat somit auch push Laufzeit O(1). Die Delegation der Pop-Operation an die Queue benötigt dann aber einen größeren Aufwand. Dazu kann zunächst ein spezielles Dummy-Element in die Queue eingefügt werden. Anschliessend werden so lange die Elemente der Queue entnommen und und direkt wieder eingefügt, bis das Dummy-Element am Kopf der Schlange auftaucht. Das zuletzt entnommene Element wird dann nicht wieder eingefügt, sondern ausgegeben. pop(s): 1 if empty(q) then return Nil enqueue(q, Dummy) 3 x dequeue(q) 4 while front(q) Dummy 5 do enqueue(q, x) 6 x dequeue(q) 7 dequeue(q) 8 return x Da jedes der n Elemente maximal einmal entnommen und eingefügt wird, ergibt sich eine Laufzeit von O(n). Selbstverständlich kann der Stack auch analog zum oben beschriebenen implementiert werden, so dass push Laufzeit O(n) und pop Laufzeit O(1) hat. Blatt 9, Aufgabe 3 Wir beweisen die Aussage durch einen Widerspruchsbeweis. Wir nehmen also an, dass es keine Teilmenge K des Universums der Größe mindestens n/m gibt, die alle auf denselben Hashwert abgebildet werden. Dieses bedeutet, dass es zu jedem der m möglichen Hashwerte höchstens n/m 1 viele Urbilder im Universum gibt. Damit gibt es dann aber höchstens m(n/m 1) < n Elemente im Universum. Dieses ist es ein Widerspruch zur Voraussetzung, dass U Größe n besitzt. Blatt 10, Aufgabe Als Datenstruktur bietet sich ein Rot-Schwarz-Baum oder ein ähnlicher balancierter binärer Suchbaum mit Höhe O(log n) an. Die Operationen Insert und Delete werden bereits wie in der Vorlesung definiert in Laufzeit O(log n) unterstützt. Als zusätzliches Satellitendatum wird zu jedem Knoten ein Wert left-size[x] gespeichert. Dieser Wert soll stets die Anzahl der Knoten im linken Teilbaum von x enthalten. Dazu werden neue Knoten welche ja stets Blätter sind mit dem Wert left-size[x] = 0 initialisiert. Da Änderungen von left-size nur die Knoten auf dem Suchpfad zur Einfüge- bzw. Löschposition betreffen, kann die Aktualisierung mit konstantem Aufwand in jedem der O(log n) Pfadknoten in die Operationen Insert und Delete eingebaut werden. Die Modifikationen ändern die asymptotische Laufzeit von Insert und Delete also nicht. Auch die Rotation des Rot-Schwarz-Baums, die in RB-Insert-Fixup auftaucht, lässt sich leicht so abändern, dass left-size erhalten bleibt und sich die Laufzeit von RB-Insert-Fixup asymptotisch nicht ändert. Schließlich muss noch Count in Laufzeit O(log n) realisiert werden. Bezeichne LessThan einen rekursiven Algorithmus, welcher die Anzahl der Elemente im Rot-Schwarz-Baum bestimmt, die kleiner k sind.

8 LessThan(k, x): 1 if x = Nil then return 0 else if k < key[x] then return LessThan(k,left(x)) 3 else return left-size[x] LessThan(k,right(x)) Dann kann Count wie folgt realisiert werden. Count(a, b): 1 x LessThan(a, root[t ]) y LessThan(b, root[t ]) 3 return y x Da LessThan den Rot-Schwarz-Baum maximal einmal von der Wurzel bis zu einem Blatt durchläuft, beträgt dessen Laufzeit O(log n). Count verwendet nun im wesentlichen nur zwei Aufrufe von LessThan, womit eine Laufzeit von O(log n) für Count folgt. Blatt 11, Aufgabe Um diese Aufgabe zu lösen, definieren wir zunächst zu jedem gerichteten Graphen G = (V, E) den Graphen G wie folgt. Die Knotenmenge von G ist die Knotenmenge V von G. Weiter ist die Kantenmenge E von G definiert durch E := {(u, v) : (v, u) E}. Wir erhalten also G aus G, in dem wir die Richtung aller Kanten in G umdrehen. Wir können auch G effizient aus G berechnen. Hierzu legen wir zunächst für jeden Knoten u V eine neue Adjazenzliste Adj[u] an. Dann durchlaufen wir die Adjazenzlisten Adj[v] für den Graphen G. Ist nun u Adj[v], so fügen wir v zur Adjazenzliste Aadj[u] hinzu. Man sieht, dass auf diese Weise die Adjazenzlistendarstellung von G in Zeit O( V + E ) aus der Adjazenzlistendarstellung von G berechnet werden kann. Als nächstes erinnern wir uns, dass wir mit Hilfe einer Breitensuche in einem (gerichteten) Graphen G alle von einem Knoten v des Graphen aus erreichbaren Knoten berechnen können. Insbesondere können wir mit einer Breitensuche feststellen, ob alle Knoten eines Graphen von einem Knoten v aus erreichbar sind. Die Zeit, die hierfür benötigt wird, ist die Laufzeit für eine Breitensuche, also O( V + E ), wobei G = (V, E). Nun können wir den Algorithmus Senkensuche beschreiben, der feststellt, ob ein gerichteter Graph eine Senke besitzt. Eingabe für den Algorithmus ist ein gerichteter Graph G = (V, E) in Adjazenzlistendarstellung. 1. Konstruiere aus G den Graphen G.. Für alle u V Senkensuche a) Entscheide mit einer in v gestarteten Breitensuche in G, ob jeder Knoten u V im Graphen G von v aus erreichbar ist. b) Ist jeder Knoten u von v aus erreichbar, return G besitzt Senke, nämlich v. 3. return G besitzt keine Senke.

9 Zunächst zeigen wir die Korrektheit des Algorithmus. Hierzu beobachten wir zunächst, dass v genau dann eine Senke in G ist, wenn jeder Knoten u in G von v aus erreichbar ist. Dieses folgt unmittelbar aus der Definition von G. Wir müssen daher noch zeigen, dass die Schritte und 3 von Algorithmus Senkensuche korrekt entscheiden, ob es in G einen Knoten v gibt, von dem aus alle Knoten u erreichbar sind. Gibt es nun einen solchen Knoten v, so wird diese beim Durchlauf des zweiten Schritts mit v als Startknoten der Breitensuche festgestellt. Dann ist die Ausgabe in Schritt b), dass G eine Senke besitzt. Besitzt hingegen G keinen Knoten, von dem aus alle Knoten erreichbar sind, so wird es in Schritt b) für keinen Knoten v zu einer Ausgabe kommen. Die Ausgabe ist dann im 3. Schritt, dass G keine Senke besitzt. Die Ausgabe ist also in jedem Fall korrekt. Nun zur Laufzeit. Der erste Schritt benötigt, wie oben angemerkt, Zeit O( V + E ). Der dritte Schritt benötigt konstante Zeit. Nach den Bemerkungen, die wir oben über die Breitensuche gemacht haben, benötigen wir für jeden Knoten v für die Schritte a) und b) Zeit O( V + E ). Damit benötigt der. Schritt für alle Knoten zusammen Zeit O( V ( V + E )) = O( V + V E ). Insgesamt also ist die Laufzeit durch O( V + V E ) gegeben. Dies beweist die Aussage der Aufgabe. Blatt 1, Aufgabe Wir zeigen die drei Aussagen jeweils durch einen Widerspruchsbeweis. a) Wir zeigen, dass G einen Kreis besitzt, falls jeder Knoten Ausgangsgrad > 0 oder jeder Knoten Eingangsgrad > 0 hat. Da die Beweise für Ausgangs- bzw. Eingangsgrad sehr ähnlich sind, führen wir den Beweis nur für den Ausgangsgrad. Sei hierzu V = n und v 1 ein beliebiger Knoten des Graphen. Da v 1 Ausgangsgrad > 0 hat, gibt es einen Knoten v, so dass (v 1, v ) E. Dann gibt es weiter einen Knoten v 3, so dass (v, v 3 ) E. Dabei muss v 3 v 1, denn sonst haben wir einen Kreis. Allgemein können wir unter der Voraussetzung, dass jeder Knoten Ausgangsgrad > 0 besitzt, zu jedem i eine Folge von Knoten v 1, v, v 3,... konstruieren, so dass (v i 1, v i ) E. Ist aber i > n, so muss es zwei Indizes k, l, l > k, geben mit v k = v l. Dann aber ist (v k, v k+1 ), (v k+1, v k+ ),..., (v l 1, v l ) ein Kreis in G. b) Wir zeigen die Aussage sogar für jeden Spannbaum, nicht nur minimalen Spannbaum. Sei also T ein Spannbaum, der die Kante e nicht enthält. Sei e = (u, v). Da T ein Spannbaum ist, gibt es in T einen Pfad P von u nach v. Der Pfad enthält die Kante e nicht, da T die Kante e nicht enthält. Dann aber ist P zusammen mit e ein Kreis in G. Dieses widerspricht der Annahme, dass e auf keinem Kreis in G enthalten ist. Also kann es den Spannbaum T, der e nicht enthält, nicht geben. c) Angenommen, es gibt zwei unterschiedliche Spannbäume T 1, T mit den Kanten e 1,..., e n 1 und f 1,..., f n 1. Wir nehmen, dass die Kanten so nummeriert sind, dass w(e 1 ) < w(e ) < < w(e n 1 ) und analog für die Kanten f i von T. Sei nun k der kleinste Index, für den e k f k gilt. Weiter nehmen wir an, dass w(f k ) > w(e k ). Nach Definition von k kann es keinen Index j < k mit f j = e k geben. Für alle Indizes j > k gilt w(f j ) > w(f k ) > w(e k ). Also gilt auch für alle Indizes j > k, dass f j e k. Damit kann e k nicht unter den kanten in T auftauchen. Wir betrachten nun den Spannbaum T erweitert um die Kante e k. In diesem Teilgraphen von G muss es nun einen Kreis geben. Da T alleine keinen Kreis enthält, muss an diesem Kreis e k beteiligt sind. Da T 1 keinen Kreis enthält, kann der Kreis nicht ausschließlich Kanten aus e j = f j, j = 1,..., k 1 enthalten. Also gibt es in dem Kreis eine Kante f j, j > k. Wir entfernen nun aus T

10 diese Kante f j und fügen e k hinzu. Dieses liefert einen neuen Spannbaum der echt kleineres Gewicht als T hat, denn w(e k ) < w(f j ) (wegen j > k und w(f k ) > w(e k )). Dieses ist aber ein Widerspruch zur Annahme, dass T ein minimaler Spannbaum ist. Damit kann es keine zwei unterschiedlichen minimalen Spannbäume geben. Blatt 13, Aufgabe 1 Sei I = {i 1,..., i r } die Indexmenge der angefahrenen Tankstellen bei einer optimalen Lösung. Sei J = {j 1,..., j s } die Indexmenge der angefahrenen Tankstellen bei einer gierigen Lösung. Wir müssen zeigen r = s. Da I zu einer optimalen Lösung gehört, gilt natürlich r s. Wir müssen also den Fall s > r ausschließen. Im Fall I = J, folgt natürlich sofort r = s. Wir können also annehmen, dass I J. Dann sei k, 1 k r, der kleinste Index mit i k j k. Das heisst, beim k-ten Tankstopp weichen die optimale und die gierige Lösung zum ersten Mal voneinander ab. Aufgrund der Definition der gierigen Strategie muss dann i k < j k gelten, denn vom k 1-ten Tankstopp t ik 1 = t jk 1 kann nicht weiter als bis zu t jk gefahren werden. Mit demselben Argument sieht man dann aber, dass i l j l fü alle l > k gilt. Insbesondere gilt i r j r. Das aber heisst, dass vom Tankstopp t jr das Ziel bereits erreicht werden kann. Denn dieses gilt für t ir und diese Tankstelle liegt vor t jr, da i r j r. Damit kann der Fall s > r nicht auftreten. Blatt 13, Aufgabe 3 Wir betrachten den Graphen in Abbildung 1. Abbildung 1: Graph für Aufgabe 13.3 Der Algorithmus Gierige-Überdeckung wird hier als erstes den Knoten c auswählen. Dann muss er aber noch aus jeder der drei Kanten (a, 1), (b, ), (d, 3) jeweils einen Knoten auswählen. Gierige-Überdeckung liefert also eine Überdeckung der Größe 4. Nun ist aber die Knotenmenge {1,, 3} bereits eine Überdeckung der Größe 3. Für diesen Fall liefert Gierige-Überdeckung also keine optimale Lösung.

11 Blatt 14, Aufgabe 1. Wir zeigen die Aussagen durch vollständige Induktion über l. Der Induktionsbeginn ist für l = 0. Erlauben wir auf einem Pfad von u nach v keine Kante, so ist nur u selber überhaupt erreichbar. Der einzige Pfad der Länge 0 von u nach u ist dann der leere Pfad, also der Pfad ohne Kanten. Damit ist für l = 0 die Aussage bewiesen. Nun zum Induktionsschluss für l > 0. Nach Induktionsvoraussetzung liefert die Formel in Teil b) dieser Teilaufgabe für l 1 und alle w V die korrekte Anzahl von Pfaden der Länge l 1 von u nach w. Für jeden Knoten v V können wir nun jeden Pfad der Länge l von u nach v eindeutig in zwei Teile aufteilen. Zunächst führt ein solcher Pfad auf einem Teilpfad der Länge genau l 1 zu einem Knoten w V, so dass (w, v) E. Der zweite Teil des Pfades der Länge l von u nach v besteht dann nur noch aus der Kante (w, v). Aus dieser Beobachtung und der Induktionsvoraussetzung folgt nun sofort die Gleichung d l (u, v) = d l 1 (u, w) für l > 0. {w V :(w,v) E}. Der folgende Algorithmus PathCount berechnet die im ersten Teil der Aufgabe aufgestellten Gleichungen. Dabei benutzt der Algorithmus ein zweidimensionales Array d mit k + 1 Zeilen und V Spalten. Der Eintrag d[l][v], 0 l k, v V, soll dabei am Ende des Algorithmus die Anzahl der Pfade der Länge l von u nach v speichern. Die gewünschte Antwort ist dann die k + 1-te Zeile d[k] des Arrays. Initialisiert werden alle Werte d[l][v] mit 0 (Zeilen 1-3). Dann wird d[0][u] auf 1 gesetzt. Damit sind dann schon alle Werte für l = 0 korrekt. Diese werden im weiteren Verlauf des Algorithmus auch nicht mehr geändert. Die Schleifen in den Zeilen 5-8 bestimmen dann iterativ die Werte d[l][v] für l = 1,..., k, mit Hilfe der im ersten Teil aufgestellten und eben bewiesenen Gleichung. PathCount(G, u, k): 1 for l 0 to k do for alle v V 3 do d[l][v] 0 4 d[0][u] 1 5 for l 1 to k 6 do for alle w V 7 do for alle v Adj[w] 8 do d[l][v] d[l][v] + d[l 1][w] 9 return d[k] Schließlich noch die Laufzeit des Algorithmus PathCount. Der ersten vier Zeilen benötigen Zeit O(k V ), da für jeden Knoten in V genau (k + 1) Werte gesetzt werden. In den Zeilen 5-8 durchlaufen wir für jeden Wert von l alle Adjazenzlisten genau einmal. Damit benötigen wir für jeden Wert von l in den Zeilen 6-8 Zeit O( V + E ). Damit ist die Laufzeit für die Zeilen 5-8 O(k( V + E )). Dieses ist dann auch die Gesamtlaufzeit von PathCount.