Algorithmen und Komplexität Lösungsvorschlag zu Übungsblatt 8

Transkript

1 ETH Zürich Institut für Theoretische Informatik Prof. Dr. Angelika Steger Florian Meier, Ralph Keusch HS 2017 Algorithmen und Komplexität Lösungsvorschlag zu Übungsblatt 8 Lösungsvorschlag zu Aufgabe 1 Wir bestimmen zuerst die Höhen h T und h T der beiden (a, b)-bäume. Da die Bäume höhenbalanciert sind, müssen wir jeweils nur von der Wurzel bis zu einem beliebigen Blatt laufen, und finden die Höhen der Bäume in O(log m + log n). Wir nehmen erst an, dass h T h T. Wir laufen im Baum T solange von der Wurzel zum rechtesten Kind bis wir einen inneren Knoten mit Tiefe h T h T erreicht haben. Sei v dieser Knoten. Nun hängen wir T an dieser Stelle ein. Das funktioniert, da alle Elemente in T grösser sind als das grösste Element in T. Wir verschmelzen also v mit der Wurzel von T. Hierbei müssen wir die Schlüsselmenge S von v durch S {g} K ersetzen, wobei g das maximale Element in T bezeichnet (wir finden dieses in Laufzeit O(log m), indem wir einfach dem rechtesten Ast in T folgen) und K die Schlüsselmenge in der Wurzel von T ist. Nun kann es natürlich passieren, dass hierdurch die (a, b)-bedingung verletzt wird. Wir müssen dann eventuell noch Rebalancierungen vornehmen, was wir mit dem gleichen Verfahren wie bei Insert(x, T) tun können, siehe Skript. Die Höhe des Baumes nimmt dabei maximal um 1 zu. Der Aufwand für die Rebalancierung ist O(log m) (siehe Skript). Für h T > h T geht man analog vor. Man geht in T nach links, bis man Tiefe h T h T erreicht hat, und hängt dort T ein. Wieder passt man die Schlüsselmengen an und muss eventuell Rebalancierungen vornehmen, was maximal Zeit O(log n) benötigt. Für den gesamten Algorithmus ergibt sich also eine Laufzeit von O(log m + log n). Beschreiben der Vorgehensweise und Begründung: 4 Punkte Laufzeit: 1 Punkt Lösungsvorschlag zu Aufgabe 2 Wir wollen einen Algorithmus mit dem Prinzip der dynamischen Programmierung konstruieren. Die folgenden Eigenschaften von längsten gemeinsamen Teilsequenzen sind die Basis dafür. Seien x (i) = x 1 x 2... x i und y (j) = y 1... y j Präfixe von x bzw. y, und sei z (k) = z 1... z k eine längste gemeinsame Teilsequenz von x (i) und y (j). Dann gilt: (1) Wenn x i = y j gilt, dann gilt auch x i = y j = z k, und z (k 1) ist eine längste gemeinsame Teilsequenz von x (i 1) und y (j 1). (2) Wenn x i = y j und z k = x i gilt, dann ist z (k) eine längste gemeinsame Teilsequenz von x (i 1) und y (j). (3) Wenn x i = y j und z k = y j gilt, dann ist z (k) eine längste gemeinsame Teilsequenz von x (i) und y (j 1). 1

2 Diese Eigenschaften sagen uns, dass wir unser ursprüngliches Problem rekursiv lösen können, indem wir jeweils ein oder zwei Unterprobleme lösen: Wenn x i = y j gilt, müssen wir eine längste gemeinsame Teilsequenz von x (i 1) und y (j 1) finden. Wenn wir x i an diese anhängen, erhalten wir eine längste gemeinsame Teilsequenz von x (i) und y (j). Falls x i = y j gilt, müssen wir eine längste gemeinsame Teilsequenz von x (i 1) und y (j) sowie von x (i) und y (j 1) finden. Die längere von beiden ist auch eine längste gemeinsame Teilsequenz von x (i) und y (j). Damit können wir eine Rekursion für dieses Problem aufstellen. Es bezeichne l i,j die Länge einer längsten gemeinsamen Teilsequenz von x (i) und y (j). Wir haben 0 falls i = 0 oder j = 0, l i,j = l i 1,j falls i, j > 0 und x i = y j, max{l i,j 1, l i 1,j } falls i, j > 0 und x i = y j. Wir können die l i,j also in bottom up -Weise gemäss dem Prinzip der dynamischen Programmierung bestimmen, indem wir die n m-matrix L = (l i,j ) 1 i n,1 j m Zeile für Zeile ausfüllen. Der Eintrag l n,m ist dann die Länge der längsten gemeinsamen Teilsequenz von x und y. Da der Wert von l i,j nur von x i, x j, l i 1,j 1, l i,j 1 und l i 1,j abhängt, können wir jeden Eintrag in konstanter Zeit berechnen. Also hat dieses Vorgehen Laufzeit O(nm). Aus der Matrix L lässt sich auch eine längste gemeinsame Subsequenz von x und y herauslesen: Wir beginnen beim Matrixeintrag l n,m rechts unten und durchlaufen einen Pfad zum Eintrag l 1,1 links oben, wobei wir in jedem Schritt nach links, oben, oder schräg links oben gehen. Dabei können wir jeweils aus den Matrixeinträgen l i,j ablesen, woher wir beim Berechnen gekommen sind. Konkret verfahren wir für den Matrixeintrag l i,j wie folgt: Solange es einen links oder oben angrenzenden Matrixeintrag l i,j 1 bzw. l i 1,j von gleichem Wert gibt, gehen wir zu diesem Eintrag und tun nichts. Falls dies nicht möglich ist, gilt nach der rekursiven Berechnungsvorschrift l i,j = l i 1,j Wir geben das Zeichen x i = y j = z k aus und gehen zum Eintrag l i 1,j 1 schräg links oben. Im Laufe dieser Durchquerung von L wird in Zeit O(m + n) eine längste gemeinsame Teilsequenz z von x und y rückwärts ausgegeben. Durch Verwenden von Pointern kann man die Zeit fürs Auslesen auf O(h) verbessern, wobei h die Länge von z bezeichnet: Zu den Matrixeinträgen l i,j speichert man jeweils einen Pointer zum letzten Matrixeintrag, wo sich die Länge von z um 1 erhöht hat. So kann man jeweils direkt (d.h. in konstanter Zeit) vom auszugebenden Zeichen z k zum auszugebenden Zeichen z k 1 hüpfen. Diese Verbesserung macht vor allem dann Sinn, wenn wir nicht nur eine, sondern viele Sequenzen aus L auslesen wollen z.b. weil wir auch an längsten gemeinsamen Subsequenzen von beliebigen Präfixen x (i), y (j) interessiert sind, oder weil wir alle längsten gemeinsamen Teilsequenzen von x und y ausgeben wollen (hierbei kann es allerdings geschehen, dass auch mit dieser Verbesserung alleine das Ausgeben der Lösungen mehr als O(nm) Zeit benötigt). Im Pseudocode- Algorithmus LÄNGSTE GEMEINSAME TEILSEQUENZ ist dies so implementiert, dass P[i, j] jeweils das letzte Zeichen der aktuell gefundenen längsten gemeinsamen Teilsequenz und die Koordinaten des Matrixeintrags direkt bevor dieses Zeichen hinzugefügt wurde enthält. Man beginnt fürs Auslesen also bei P[n, m], gibt für P[n, m] = (a, (i, j)) das Zeichen a aus und findet in P[i, j] das nächste Zeichen sowie einen Pointer zum übernächsten Zeichen. Wie vorher wird so eine längste gemeinsame Teilsequenz rückwärts ausgegeben. Definition l i,j : 1 Punkt Rekursionsformel für l i,j : 2 Punkte 2

3 Algorithm 1 LÄNGSTE GEMEINSAME TEILSEQUENZ(Strings x[1..m], y[1..n]) L[0..n, 0..m] := new Array of Integers P[0..n, 0..m] := new Array of Characters and Pointers (char, (i, j)) for i = 0 to n do L[i, 0] := 0; P[i, 0] := (nil, nil) for j = 0 to m do L[0, j] := 0; P[0, j] := (nil, nil) for i = 1 to n do for j = 1 to m do if x[i] = y[j] then L[i, j] := L[i 1, j 1] + 1; P[i, j] := (x[i], (i 1, j 1)) else if L[i, j 1] L[i 1, j] then L[i, j] := L[i, j 1]; P[i, j] := P[i, j 1] else L[i, j] := L[i 1, j]; P[i, j] := P[i 1, j] Begründung der Formel: 3 Punkte Algorithmus und Laufzeit: 2 Punkte LGTS ausgeben: 2 Punkte Lösungsvorschlag zu Aufgabe 3 Ein naheliegendes Vorgehen zur Lösung dieser Aufgabe ist ein Greedy-Ansatz: sortiere die Jobs absteigend nach Profit und nimm in dieser Reihenfolge diejenigen Jobs in die Auswahl J auf, die J nicht unzulässig machen. Algorithm 2 GREEDY Ordne die Jobs nach absteigenden Gewinnen: p 1 p 2 p n J := for i = 1 to n do if J {i} ist zulässige Lösung then J := J {i} Zur Laufzeit: Das einmalige Sortieren der Jobs nach Profit kostet O(n log n) Zeit. Um zu zeigen, dass die for-schleife in Zeit O ( n 2) ausgeführt wird, genügt es zu zeigen, dass in Zeit O(n) entschieden werden kann, ob eine Menge J zulässig ist. Eine Menge J ist genau dann zulässig, wenn für 1 a k gilt, dass höchstens a Jobs Schlusstermin kleiner gleich a haben. Wenn wir davon ausgehen, dass die Menge J aufsteigend nach Schlussterminen geordnet ist, d.h. J = {i 1,..., i k } mit d i1 d ik, ist dies äquivalent zu d ia a für 1 a k. 3

4 Es bietet sich also an, die Menge J als verkettete Liste zu implementieren, in der die Jobs nach aufsteigenden Schlussterminen geordnet sind. Mit dieser Datenstruktur kann sowohl das Einfügen als auch das Überprüfen der Bedingung d ia a in Zeit O(n) erledigt werden. Zur Korrektheit: Um zu zeigen, dass dieser Ansatz tatsächlich korrekt ist, zeigen wir, dass die zugrundeliegende algebraische Struktur ein Matroid ist. Wenn wir das Gewicht von Job i als w i := p i setzen, entspricht das maximieren des Profits exakt dem Minimieren bezüglich Gewichtsfunktion w i. Dann folgt die Korrektheit aus Satz 3.7. Wir müssen also die Matroid-Struktur verifizieren. Als Grundmenge wählen wir S = I = {1,..., n}, und als Mengensystem U über S betrachten wir die Menge der zulässigen Lösungen J I. Mit der Gewichtsfunktion w(i) := p i stimmt der Algorithmus GREEDY mit dem kanonischen Greedy-Algorithmus für Matroide aus der Vorlesung überein. Nun müssen wir überprüfen, ob die Matroidaxiome erfüllt sind. (M1) U. Das ist klar. (M2) Sei J U und J J, d.h. J umfasst eventuell einige Jobs aus J nicht. Da J zulässig ist, ist J sicher auch zulässig und somit J U. (M3) Seien J, J U mit J = J + 1. Wir wollen zeigen, dass es ein j J \ J gibt, so dass J {j} zulässig ist. Um die Notation zu vereinfachen, nehmen wir an, dass die zulässigen Mengen J und J aufsteigend nach Schlussterminen geordnet sind. Sei also J = k und J = {i 1, i 2,..., i k } mit d i1 d i2 d ik. Analog sei J = {i 1, i 2,..., i } mit d i 1 d i 2 d i, wobei natürlich i a und i b das gleiche Element aus I bezeichnen können, wenn dieses sowohl in J als auch in J vorkommt. Sei nun j = i t J \ J das Element mit maximalem Index in J, das nicht in J enthalten ist. Hierbei gilt offensichtlich 1 t k + 1. Die k + 1 t Elemente i t+1,..., i in J mit grösserem Index sind also alle auch in J enthalten. Nach Annahme an J können diese zulässig zu den Zeitpunkten {t + 1,..., k + 1} abgearbeitet werden (J 1 in Abbildung 1 auf der nächsten Seite). Das neue Element j (= i t ) wird zum Zeitpunkt t erledigt (J 2 in Abbildung 1). Es verbleiben genau t 1 Elemente von J, für welche nach Annahme an J eine zulässige Zuordnung auf eine Teilmenge von {1,..., k} existiert. Insbesondere können wir diese zu den Zeitpunkten {1,..., t 1} abarbeiten. (Man beachte, dass mit dieser Konstruktion alle Elemente von J, welche nicht in J vorkommen, nun bereits während der Zeitspanne {1,..., t 1} abgearbeitet werden.) Damit wurde gezeigt, dass eine zulässige Anordnung der Elemente von J {j} existiert. Also ist J {j} eine zulässige Lösung, J {j} U. (S, U) ist also ein Matroid, und die Korrektheit von GREEDY folgt aus Satz 3.7 der Vorlesung. Greedy-Algorithmus: 2 Punkte zulässigkeit in O(n) testen und Laufzeit O(n 2 ): 2 Punkte Idee Matroid beweisen: 1 Punkte M1 und M2: 1 Punkte M3: 4 Punkte 4

5 Zeit 1 t 1 t t + 1 J i 1 i t 1 i t i t+1 i J i 1 i i t 1 J 1 i i 1 i t 1 J 2 i i 1 i t 1 i t Abbildung 1: Beweis von (M3): wir können i t in J einfügen 5