Kapitel 5. Textalgorithmen. 5.1 Grundbegriffe

Transkript

1 Kapitel 5 Textalgorithmen 5.1 Grundbegriffe Wir beschäftigen uns hauptsächlich mit Textsuche (und Varianten). Gegeben: Alphabet Σ (mindestens zwei Buchstaben). Text S = s 1... s n Σ in Array S[1..n]. Muster P = p 1... p m Σ in Array P[1..m]. Aufgabe: Finde erstes (oder: alle) Vorkommen von P in S, d. h. finde kleinstes oder einige oder alle l {1,..., n m + 1} mit P = s l... s l+m 1. Beispiel: (Blanks zählen als Buchstaben, alle Vorkommen finden) P = NADEL S = IM HEUHAUFEN DIE NADEL FINDEN Ausgabe: {18} S = IM NADELHAUFEN DIE NADEL FINDEN Ausgabe: {4, 20} S = IM WALD DEN BAUM FINDEN Ausgabe: 1

2 Naiver Algorithmus: Für jedes l {1,..., n m+1}: Vergleiche P Buchstabe für Buchstabe mit s l... s l+m 1, bis mismatch gefunden (Stelle p j mit p j s l+j 1 ) oder bis Übereinstimmung aller m Buchstaben festgestellt. Laufzeit: O((n m + 1)m) im schlechtesten Fall. (Oft geringer.) Schlechtester Fall: S = a n 1 b, P = a m 1 b. Hier benötigt der naive Algorithmus exakt (n m+1)m Vergleiche von Buchstaben, wenn man die Vergleiche in der Reihenfolge j = 1, 2,..., m vornimmt. Ziel: Laufzeiten O(m + n). Zentraler Grundbegriff: Ränder. Sei W = a 1... a t ein Wort. Wir schreiben W [i..j] für a i... a j (für 1 i j t). Wenn i > j ist, soll W [i..j] = ε, das leere Wort, sein. Definition Sei W = a 1... a t ein Wort. W [1..s] heißt ein Rand von W, wenn W [1..s] (nicht nur Präfix, sondern auch) Suffix von W [1..t] ist. Beispiel: Die Ränder von abababcabab sind: ε, ab, abab und abababcabab. Die Ränder von ababa sind ε, a, aba und ababa. W selbst ist immer Rand von W, er heißt uneigentlicher Rand (und wird nicht berücksichtigt). Die anderen Ränder heißen echte Ränder. Wenn W = t 1 ist, ist auf jeden Fall das leere Wort W [1..0] = ε echter Rand von W. W = ε hat nur sich selbst als (uneigentlichen) Rand, besitzt also keinen echten Rand. Uns interessiert oft der längste echte Rand. Der längste echte Rand von ababab ist abab, der längste echte Rand von ababcabc ist ε. Definition (MP-Fehlerfunktion). Gegeben sei das Muster P [1..m]. Wir definieren eine Funktion f : {0, 1,..., m} { 1, 0,..., m 1} { Länge des längsten echten Randes von P [1..q], falls 1 q m; f(q) := 1, falls q = 0. Offensichtlich ist immer f(q) < q. Der Fall f(0) = 1 ist ein Sonderfall, aus (programmier-)technischen Gründen so festgelegt. 2

3 Abbildung 5.1: MP-Fehlerfunktion f bei P [1..12] = abababcababa: q P[q] a b a b a b c a b a b a f(q) Der Algorithmus von Knuth, Morris und Pratt Vorüberlegungen und Formulierung Die Grundidee des KMP-Algorithmus ist, für jedes i, 0 i n, das folgende Hilfsproblem (HP i ) zu lösen: (HP i ) Finde das längste echte Präfix P [1..q] des Musters (also q < m), das Suffix von S[1..i] ist, d. h. das P [1..q] = S[i q + 1..i] erfüllt. (Dieses größte q heißt im Folgenden q i.) Beispiel: abaababcabababcabababc: Text abababcababa: Muster Text a b a a b a b c a b a b a b c a b a b a b c i q i Zum Beispiel ist P [1..q 13 ] = P [1..5] = ababa das längste Präfix von P, das Suffix von S[1..13] = abaababcababa ist, und P [1..q 20 ] = P [1..5] ist auch das längste echte Präfix von P, das Suffix von S[1..20] = abaababcabababcababa ist. Wenn alle Hilfsprobleme gelöst sind, ist die Suche nach dem Muster P in S sehr einfach: Lemma Für jedes i, 1 i n, ist P [1..m] = S[i m+1..i] genau dann wenn q i 1 = m 1 und P [m] = S[i] gilt. 1 1 Achtung! Der Test ist q i = m? ist nicht geeignet, da nach der Definition q i < m sein muss. 3

4 Beweis: : Wenn P [1..m] = S[i m + 1..i], ist P [m] = S[i] und P [1..m 1] = S[i m + 1..i 1]. Nach Definition von q i 1 folgt q i 1 m 1, aber auch q i 1 < m. Also ist q i 1 = m 1. : Aus q i 1 = m 1 folgt P [1..m 1] = S[i m + 1..i 1]. Wenn zusätzlich P [m] = S[i] ist, folgt P [1..m] = S[i m + 1..i]. Im Beispiel tritt die Bedingung des Lemmas für i = 20 ein. Aus dem Beispiel hat man auch den Eindruck, dass es zwei Möglichkeiten gibt, von q i 1 nach q i zu kommen: entweder ist q i = q i oder es erfolgt ein Rücksprung, höchstens bis zur 0. Das Hochzählen sollte einfach sein. Man hofft nun, auch die Rücksprünge einigermaßen effizient organisieren zu können. Hierbei spielt die Fehlerfunktion die entscheidende Rolle. Zunächst setzen wir voraus, dass wir eine Tabelle haben, aus der die Fehlerfunktions- Werte f(q), 0 q m, abgelesen werden können. Der Algorithmus läuft in Runden i = 1, 2,..., n ab. In Runde i wird vorausgesetzt, dass die Lösung q i 1 für (HP i 1 ) vorliegt, und es wird q i berechnet. Auch der Test, ob P [1..m] = S[i m + 1..i] ist, gehört natürlich zu Runde i. In einer (gedachten) Runde i = 0 muss man nur q 0 := 0 setzen. Dies löst (HP 0 ), denn S[1..0] = ε hat nur P [1..0] = ε als Suffix. Die Menge A der Indizes, an denen ein Vorkommen von P beginnt, wird mit initialisiert. Angenommen nun, 1 i n, Runde i 1 ist erfolgreich abgeschlossen und hat q = q i 1 < m geliefert, wie in (HP i 1 ) verlangt. Wir beschreiben Runde i. Es gibt drei Fälle. 1. Fall: P [q + 1] = S[i] und q + 1 = m. Nach Lemma wurde jetzt das Muster als S[i m + 1..i] im Text gefunden. Wir notieren dies: A := A {i m + 1}. Wenn nur nach einem Vorkommen von P in S gefragt ist, kann man jetzt aufhören. 2 Wenn nach allen Vorkommen gefragt ist, muss Runde i + 1 vorbereitet werden. Wir suchen also das längste echte Präfix P [1..q i ] des Musters P, das Suffix von S[1..i] ist. Es muss dann notwendigerweise gelten: P [1..q i ] = S[i q i + 1..i] = P [m q i + 1..m]. 2 Wenn i = n ist, könnte man auch hier stoppen. Es spart aber einen Test in jeder Runde und kostet praktisch nichts, sich hierum nicht zu kümmern. 4

5 Das heißt, dass q i die Länge des längsten echten Randes von P [1..m] ist. Es gilt also q i = f(m); wir sind fertig für die nächste Runde. Im folgenden Beispiel sieht man eine Situation, in der in Runde i = 20 Muster P = abababcababa unter S[i m + 1..i] passt (der 1. Fall tritt ein) und bei der P [1..f(m)] = P [1..5] das längste echte passende Präfix ist. Runde 20: Text a b a a b a b c a b a b a b c a b a b a b c i Muster a b a b a b c a b a b a P [1..f(12)] a b a b a 2. Fall: P [q + 1] = S[i] und q + 1 < m. Wir wissen dann, dass P [1..q + 1] = S[i q..i] gilt, und dass dies das längstmögliche Präfix von P ist, das als Suffix auf S[1..i] passt : das folgt aus der Maximalität von q i 1. Es gilt also q i = q i 1 + 1; wir gehen damit zu Runde i. Im obigen Beispiel tritt der 2. Fall in vielen Runden ein, zum Beispiel bei i = 16. Muster: abababcababa. Runde 16: q 15 = 7, q 16 = 8 Text a b a a b a b c a b a b a b c a b a b a b c i P [1..7] a b a b a b c P [1..8] a b a b a b c a 3. Fall: P [q + 1] S[i]. ( Mismatch.) Wir suchen nun das längste Präfix P [1..q + 1] des Musters, das Suffix von S[1..i] ist. Für jedes solche q muss gelten, dass P [1..q ] Suffix von S[1..i 1] ist. Das heißt: P [1..q ] = S[i q..i 1] = P [q q + 1..q]. (5.1) Das heißt, es kommen nur q < q in Frage, für die P [1..q ] ein echter Rand von P [1..q] ist. (Solche q heißen zulässig.) Von diesen q suchen wir das größte, das obendrein P [q + 1] = S[i] erfüllt. Um hier nichts falsch zu machen, probieren wir die zulässigen q der Größe nach durch: zuerst den längsten echten Rand, dann den zweitlängsten, usw. Dazu benutzen wir die Fehlerfunktion und organisieren die Suche wie folgt: 5

6 Beginne mit q = q, und iteriere folgendes: q := f(q ) (längster echter Rand von P [1..q ]). Teste, ob P [q + 1] = S[i]. Dies wird wiederholt, bis einmal P [q +1] = S[i] ist. Dann ist das richtige q gefunden, es gilt dann q i = q + 1. Es kann auch passieren, dass alle q durchlaufen werden, ohne eine Übereinstimmung. Dies merkt man daran, dass selbst für den kürzesten echten Rand P [1..0] = ε der Test P [1] = S[i]? negativ ausgeht. Dann wird q = 1 gesetzt, die Iteration bricht ab. Der richtige Wert für q i ist 0 = ( 1) + 1 = q + 1. Im obigen Beispiel tritt der 3. Fall zum Beispiel in Runde i = 7 ein. Muster: abababcababa. Abbildung 5.2: Beispiel für 3. Fall: Runde 8, q 7 = 4, q 8 = 0, P [1..q 8 ] = P [1..0] = ε ist das längste Präfix von P, das Suffix von S[1..8] ist. Es wird q = f(q 7 ) = f(4) = 2, q = f(2) = 0 untersucht und q = 1 erreicht, was dann zu q 8 = 0 führt. Mismatch- Buchstaben sind unterstrichen. Text a b a a b a b c a b a b a b c a b a b a b c i P [1..4] a b a b P [1..5] a b a b a P [1..3] a b a P [1..1] a P [1..0] Programmtechnische Umsetzung: Die Runden werden über eine (äußere) for-schleife realisiert. (Der Inhalt der Variablen i gibt immer die aktuelle Runde an.) Die Werte q i und die Zwischenwerte q werden alle in ein und derselben Variablen q geführt, die Suche im 3. Fall findet in einer inneren while-schleife statt. Man beachte (und staune über) die extrem kompakte Umsetzung als Programm. 6

7 Algorithmus (Knuth-Morris-Pratt). KMP-Textsuche(S[1..n],P[1..m]) Eingabe: P[1..m]: Muster; S[1..n]: Text; Vorberechnet: f[0..m]: (K)MP-Fehlerfunktion als Tabelle; Ausgabe: Menge A {1,..., n m + 1}; initialisiert: A ; (1) int q 0; (2) for i from 1 to n do (3) while q 0 P[q+1] S[i] do q f[q]; (4) q q+1; (5) if q = m (6) then A A {i-m+1}; q f[m]; (7) return A. Wo findet man die Runden und die Fälle im Programm? Runde i ist der Durchlauf der for-schleife, in dem i die Zahl i enthält. Aber der 1. Fall und der 2. Fall sind kaum zu identifizieren. Die Initialisierung, Runde 0, besteht aus der Zuweisung q 0. Runde i: Wir setzen voraus, dass q den Wert q i 1 enthält. Wenn in Zeile (3) festgestellt wird, dass P[q i 1 +1] = S[i] gilt, ist man im 1. Fall oder im 2. Fall. Der Rumpf der Schleife in Zeile (3) wird nicht ausgeführt, in Zeile (4) wird q auf q i gesetzt. Wenn in Zeile (5) festgestellt wird, dass q i = m ist, sind wir im 1. Fall: in Zeile (6) wird notiert, dass P gefunden wurde, und es wird q auf den richtigen Wert q i = f(m) gesetzt. Wenn in Zeile (5) festgestellt wird, dass q i < m ist, sind wir im 2. Fall: hier hat q schon den richtigen Wert q i = q i für die nächste Runde. Wenn in Zeile (3) festgestellt wird, dass P[q i 1 +1] S[i] gilt, beginnt der als 3. Fall beschriebene Ablauf, alles in der Schleife in Zeile (3). Die beiden Tests in Zeile (3) werden natürlich nacheinander ausgeführt; die Schleife endet, wenn der Inhalt q von q auf den Wert 1 gefallen ist oder wenn er 0 ist und P[q+1] = S[i] ist. Wenn diese Schleife mit einem Wert q 0 in q verlassen wird, dann ist S[i] = P [q + 1]. Es wird q um 1 erhöht (entspricht q i = q + 1) und zur nächsten Runde gegangen. Wenn die Schleife mit dem Wert q = 1 in q verlassen wird, wird der nächsten Runde in q der Wert q i = ( 1) + 1 = 0 übergeben. 7

8 5.2.2 Analyse des KMP-Algorithmus Zu klären sind noch: Laufzeit und Korrektheit. (Für die Korrektheit sollte man aufgrund der Vorüberlegungen schon ein gutes Gefühl haben.) Satz In Algorithmus werden maximal 2n Vergleiche zwischen Zeichen durchgeführt; die Laufzeit ist O(n). Beweis: Die Initialisierung und die Organisation der äußeren for-schleife kostet auf jeden Fall nur O(n) Zeit. Das einzige Problem ist die Anzahl der Durchläufe durch Test und Rumpf der while-schleife in Zeile (3). Dafür beobachten wir den Inhalt der Variablen q. 3 Anfangs ist er 0. Der Inhalt von q wächst nur in Zeile (4), um 1. Das passiert exakt n-mal. In jedem Durchlauf durch den Schleifenrumpf in Zeile (3) wird q echt verringert. Am Ende des ganzen Algorithmus steht q mindestens auf 0. Also gibt es höchstens n Durchläufe durch den Rumpf von (3), und die Gesamtzeit ist O(n). Zur Anzahl der Vergleiche: Es kann maximal n-mal vorkommen, dass P[q+1] S[i] festgestellt wird (weil dies eine Verringerung von q zur Folge hat) und maximal n-mal, dass P[q+1] = S[i] festgestellt wird (weil damit die Schleife in Zeile (3) verlassen wird). Satz Algorithmus liefert die Menge aller Positionen zurück, an denen ein Vorkommen des Musters in S beginnt. Beweis: Alles ist in der Vorüberlegung schon geklärt, insbesondere besagt Lemma 5.2.1, dass alle Vorkommen von P in S gefunden werden, wenn nur zu Beginn jeder Runde in q der richtige Wert q i steht. Nur dies müssen wir noch zeigen. Insbesondere die Wirkungsweise der while-schleife im 3. Fall muss noch kontrolliert werden. Hierfür formulieren wir eine Invariante, für 1 i n und 1 q < m: (I i,q ): P [1..q ] = S[i q..i 1] und r, q < r < i: P [1..r + 1] = S[i r..i]. (Das Präfix P [1..q ] passt als Suffix auf S[1..i 1], aber es gibt kein längeres Präfix P [1..r], das auch passt und zudem noch P [r + 1] = S[i] erfüllt.) Lemma Betrachte Runde i (in i). Dann gilt: (a) Bei Rundenbeginn enthält q den in (HP i 1 ) definierten Wert q i 1. 3 Technisch könnte man auch den Inhalt q als Potential definieren und eine formale amortisierte Analyse durchführen. Hier ist aber die direkte Überlegung einfacher. 8

9 (b) (I i,q ) gilt für den Inhalt q von q, immer vor dem Test in der while-schleife in Zeile (3) und nach vollständiger Ausführung von Zeile (3). Beweis: Beide Aussagen werden durch eine (verschränkte) Induktion bewiesen, die die Rechenschritte in ihrem zeitlichen Ablauf verfolgt. In Runde 0 wird der richtige Wert q 0 = 0 in q gespeichert. Runde i: Betrachte Zeile (3). Die Invariante (I i,q ) gilt vor dem ersten Schleifentest, da q dann q i 1 enthält und P [1..q i 1 ] (nach I.V.) das längste echte Präfix von P überhaupt ist, das Suffix von S[1..i 1] ist. Unterinduktion: Angenommen, q 0 (in q) erfüllt (I i,q ) und der Schleifentest in Zeile (3) wird durchgeführt. Wenn er Ergebnis false hat, ändert sich q nicht, und (I i,q ) gilt auch zu Beginn von Zeile (4). Nun betrachte den Fall, wo der Schleifentest das Ergebnis true liefert. Dann ist q 0. Fall (i): q = 0: Aus der Invarianten (I i,q ) für q = 0 und dem Testergebnis P [1] S[i] schließen wir, dass überhaupt kein nichtleeres Präfix von P Suffix von S[1..i] ist. Das ist (I i,q ) für q = 1. Durch den Schleifenrumpf erhält q den Wert 1. Fall (ii): q > 0: Betrachte q := f(q ), den neuen Wert in q. Wir zeigen (I i,q ). Weil P [1..q ] Rand von P [1..q ] ist, und weil (I i,q ) gilt, folgt P [1..q ] = P [q q + 1..q ] = S[i q..i 1]. Nun sei P [1..r + 1] = S[i r..i]. Nach (I i,q ) folgt r q. Wegen des Schleifentests gilt r q, also sogar r < q. Weiter haben wir P [1..r] = S[i r..i 1] = P [q r + 1..q ], was bedeutet, dass P [1..r] ein echter Rand von P [1..q ] ist, und nach der Wahl von q folgt daraus r q. Damit gilt (I i,q ). Damit ist die Unterinduktion beendet, und wir betrachten noch, was in Runde i ab Zeile (4) passiert. Fall (j): Zu Beginn von Zeile (4) hat q den Wert q = m 1. Nach (I i,q ) (erster Teil) und dem Schleifentest gilt P [1..m] = S[i m + 1..i]. Mit Zeile (4) erhält q den Wert m, mit Zeile (6) den Wert q i = f(m). Damit gilt Aussage (a) für Runde i + 1. Fall (jj): Zu Beginn von Zeile (4) steht in q ein Wert 0 q < m 1. Nach (I i,q ) (erster Teil) gilt P [1..q ] = S[i q..i 1], wegen des Schleifentests gilt P [1..q +1] = S[i q..i], nach (I i,q ) (zweiter Teil) gilt für kein r > q, dass P [1..r + 1] = S[i r..i] ist. Das bedeutet, dass q i = q + 1 gilt. Zeile (4) schreibt diesen Wert nach q. Fall (jjj): Zu Beginn von Zeile (4) steht in q der Wert q = 1. Dann ist kein nichtleeres 9

10 Präfix von P Suffix von S[1..i], d. h. q i = 0. Durch Zeile (4) wird dieser Wert nach q geschrieben. Damit ist Lemma bewiesen, und auch Satz Die Berechnung der Fehlerfunktion Es bleibt noch zu zeigen, wie die Fehlerfunktion f in Zeit O(m) berechnet werden kann. Nach Definition ist f(0) = 1 und f(1) = 0. Für 2 i m müssen wir folgendes Problem lösen: (HP f i ) Finde das längste echte Präfix P [1..q] von P [1..i], das auch Suffix von P [1..i] ist, d. h. finde das größte q < i, das P [1..q] = P [i q+1..i] erfüllt. (Dieses maximale q ist f(i).) Dies sieht dem Hilfsproblem (HP i ) von oben sehr ähnlich nur übernimmt hier P auch die Rolle des Textes. Der Trick ist, dass man tatsächlich den KMP-Algorithmus benutzen kann: für die Berechnung von f(i) werden nur Werte f(q) mit q < i benötigt, die also schon vorher berechnet wurden. Algorithmus (MP: Berechnung der einfachen Fehlerfunktion). MP-Preprocessing(P[1..m]) Eingabe: P[1..m]: Muster; Ausgabe: f[0..m]: MP-Fehlerfunktion als Tabelle; (1) f[0] 1; (2) int q 1; (3) for i from 1 to m do (4) while q 0 P[q+1] P[i] do q f[q]; (5) q q+1; (6) f[i] q; (7) return f[0..m]. Satz Algorithmus berechnet die MP-Fehlerfunktion korrekt. Die Laufzeit ist O(m). Beweis: Die Aussage zur Laufzeit zeigt man exakt wie beim KMP-Algorithmus selbst (Satz 5.2.3). Bei der Korrektheit geht man ebenfalls so ähnlich vor wie beim KMP- Algorithmus (Satz 5.2.4). Man formuliert folgende Invariante, für 2 i m und 0 q < i 1: 10

11 (I f i,q ): P [1..q ] = P [i q..i 1] und r, q < r < i 1: P [1..r + 1] = P [i r..i]. (P [1..q ] ist echter Rand von P [1..i 1], und es gibt keinen längeren echten Rand P [1..r], der zudem P [r + 1] = P [i] erfüllt.) Man beweist die Invariante und die Korrektheit der Beschriftung des f-arrays wie bei Satz durch (verschränkte) Induktion über die Schleifendurchläufe. Klar ist, dass f[0] und f[1] richtig mit f(0) und f(1) besetzt werden und dass bei Eintritt in Runde 2 die Zahl q = f(1) = 0 in q steht. Nun betrachten wir Runde i 2 und nehmen an, dass f[0..i 1] die richtigen Werte f(0),..., f(i 1) enthält und dass in q der Wert q = f(i 1) < i 1 steht. Betrachte Zeile (4). Die Invariante (I f i,q ) gilt vor dem ersten Schleifentest, da q dann f(i 1) enthält und P [1..f(i 1)] (nach Definition von f(i 1)) der längste echte Rand von P [1..i 1] ist. Unterinduktion: Angenommen, q 0 (in q) erfüllt (I f i,q ) und der Schleifentest in Zeile (4) wird durchgeführt. Wenn er Ergebnis false hat, ändert sich q nicht, und (I f i,q ) gilt auch zu Beginn von Zeile (5). Es gilt weiterhin 0 q < i 1. Nun betrachte den Fall, wo der Schleifentest das Ergebnis true liefert. Dann ist q 0. Fall (i): q = 0: Aus der Invarianten (I f i,q ) für q = 0 und dem Testergebnis P [1] P [i] schließen wir, dass überhaupt kein nichtleeres Präfix von P Suffix von P [1..i] ist. Durch den Schleifenrumpf und die nachfolgende Zeile erhält q den Wert 1. Fall (ii): q > 0: Betrachte q := f(q ), den neuen Wert in q. Genau wir im Beweis von Lemma zeigt man, dass (I f i,q ) gilt. Damit ist die Unterinduktion beendet, und wir überlegen noch, was in Runde i ab Zeile (5) passiert. Fall (j): Zu Beginn von Zeile (5) steht in q ein Wert 0 q < i 1. Nach (I f i,q ) (erster Teil) ist P [1..q ] echter Rand von P [1..i 1], wegen des Schleifentests gilt P [q + 1] = P [i q..i], nach (I f i,q ) (zweiter Teil) ist für kein r > q P [1..r + 1] Rand von P [1..i]. Das bedeutet, dass f(i) = q + 1 gilt; dies ist ein Wert < i. Zeilen (5) und (6) schreiben diesen Wert nach q und f[i]. Fall (jj): Zu Beginn von Zeile (5) steht in q der Wert q = 1. Dann hat P [1..i] keinen nichtleeren echten Rand, d. h. f(i) = 0. Zeilen (5) und (6) schreiben diesen Wert nach q und f[i]. 11

12 5.2.4 Eine verbesserte Fehlerfunktion: KMP Nehmen wir an, dass in Zeile (3) des KMP-Algorithmus beim ersten Versuch ein Mismatch auftritt, dass also P [q i 1 + 1] S[i] ist. Im Algorithmus wird nun für die echten Ränder P [1..q ] von P [1..q i 1 ] (in der Reihenfolge fallender Länge) getestet, ob P [q + 1] = S[i] ist. Dieser Test ist überflüssig und das entsprechende q braucht gar nicht betrachtet zu werden wenn P [q + 1] = P [q i 1 + 1] ist, weil man dann schon weiß, dass P [q + 1] = P [q i 1 + 1] S[i] ist. (Ein Beispiel für diese Erscheinung findet man in Abbildung 5.2. Es wird mehrmals a mit c verglichen.) Wir definieren eine etwas schärfere Fehlerfunktion, die dies berücksichtigt. Sie verringert möglicherweise die Anzahl der mismatch -Vergleiche 4. 1, falls q = 0 oder falls 1 q < m und P [q + 1] = P [q + 1] für alle echten Ränder P [1..q ] von P [1..q]; f (q) := q, falls 1 q < m und q = Länge des längsten echten Randes P [1..q ] von P [1..q] mit P [q + 1] P [q + 1] (und so etwas existiert); q, falls q = m und q = Länge des längsten echten Randes von P [1..m]. Wenn man die MP-Fehlerfunktion f schon berechnet hat, erhält man f durch folgende Rekursionsgleichung: f(q), falls q {0, m}; f (q) = f(q), falls 1 q < m und P [q + 1] P [f(q) + 1]; f (f(q)), falls 1 q < m und P [q + 1] = P [f(q) + 1]. (Der Beweis ist eine Übungsaufgabe.) Man kontrolliere, dass aus der Funktion f in Abb. 5.1 durch Anwendung dieser rekursiven Vorschrift die folgende modifizierte Funktion f entsteht. Diese sollte man dann einmal mit dem Muster S[1..22] von oben durchlaufen lassen, um zu sehen, wie bei i = 8 wiederholte identische Tests vermieden werden. Durch eine leichte Modifikation von Algorithmus (Zeile (6) wird durch eine bedingte Zuweisung ersetzt) erhält man die modifizierte Fehlerfunktion unmittelbar: 4 Das ist die Variante des KMP-Algorithmus, die in der endgültigen veröffentlichten Version beschrieben ist: [Donald E. Knuth, James H. Morris Jr., Vaughan R. Pratt: Fast Pattern Matching in Strings. SIAM J. Comput. 6(2): (1977)]. Diese Arbeit enthält auch einen interessanten Bericht über die Entstehung des Algorithmus. 12

13 Abbildung 5.3: MP- und KMP-Fehlerfunktion f und f bei P [1..12] = abababcababa: q P[q] a b a b a b c a b a b a f(q) f (q) Algorithmus (KMP: Berechnung der modifizierten Fehlerfunktion). KMP-Preprocessing(P[1..m]) Eingabe: P[1..m]: Muster; Ausgabe: f[0..m]: KMP-Fehlerfunktion als Tabelle; (1) f[0] 1; (2) int q 1; (3) for i from 1 to m do (4) while q 0 P[q+1] P[i] do q f[q]; (5) q q+1; (6) if i m or P[q+1] P[i+1] (7) then f[i] q (8) else f[i] f[q]; (9) return f[0..m]. Wenn man die hier berechnete modifizierte Fehlerfunktion in Algorithmus einsetzt, erhält man den eigentlichen KMP-Algorithmus. 13