Algoritmen en Datastructuren III Partim: Algoritmen voor strings - caagt

Algoritmen en Datastructuren III 

Partim: Algoritmen voor strings 

Veerle Fack 

3 december 2008

Inhoudsopgave 

1 Algoritmen voor exact string-matching 1 

1.1 Een eenvoudig brute-kracht-algoritme . . . . . . . . . . . . . . . . . . . . . . . 2 

1.2 Het algoritme van Rabin-Karp . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 

1.3 Het algoritme van Knuth-Morris-Pratt . . . . . . . . . . . . . . . . . . . . . . . 6 

1.3.1 Inefficiëntie van het brute-kracht-algoritme . . . . . . . . . . . . . . . . 6 

1.3.2 Gebruik van een verschuivingstabel voor het patroon . . . . . . . . . . . 7 

1.3.3 Het algoritme van Knuth-Morris-Pratt . . . . . . . . . . . . . . . . . . . 9 

1.3.4 Berekenen van de verschuivingstabel . . . . . . . . . . . . . . . . . . . 11 

1.4 Het algoritme van Boyer-Moore-Horspool . . . . . . . . . . . . . . . . . . . . . 12 

1.4.1 De occurrence-heuristiek . . . . . . . . . . . . . . . . . . . . . . . . . . 12 

1.4.2 De match-heuristiek . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 

1.4.3 Het algoritme van Boyer-Moore-Horspool . . . . . . . . . . . . . . . . . 15 

2 Algoritmen voor benaderend string-matching 19 

2.1 Editeerafstand tussen strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 

2.2 Beste benaderende match . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 

i

Hoofdstuk 1 

Algoritmen voor exact 

string-matching 

Het zoeken van patronen in tekst is een alomtegenwoordig probleem, overal waar informatie 

bijgehouden en opgeslagen wordt. Toepassingen gaan van zoekrobots op het Internet tot het 

zoeken van woorden in bestanden op de eigen computer, evenals het zoeken van sequenties 

in biologische databanken. De algemene vorm van het probleem bestaat erin om in een tekst 

een match voor een patroon te vinden, waarbij de begrippen “tekst”, “patroon” en “match” op 

verschillende manieren kunnen geïnterpreteerd worden. 

1

2 Hoofdstuk 1. Algoritmen voor exact string-matching 

In dit deel zullen we de volgende terminologie gebruiken. Meestal noteren we door P het patroon 

dat gezocht wordt, en door T de tekst waarin het patroon gezocht wordt. Doorgaans veronderstellen 

we ook dat het onderliggende alfabet Σ vast is. Meestal bestaat dit alfabet uit de gebruikelijke 

letters, cijfers en leestekens. In bepaalde gevallen zullen we ons echter beperken tot het binaire 

alfabet Σ = {0,1}. De verzameling van alle (eindige) woorden op het alfabet Σ wordt genoteerd 

als Σ ∗ ; {0,1} ∗ is dus de verzameling van alle binaire strings. 

De lengte van een string S noteren we door |S|. Meestal noteren we m = |P| en n = |T|, en we 

veronderstellen dat m ≤ n. Door P[i.. j] noteren we de substring van P die begint op positie i en 

eindigt op positie j. Dus P[0..m−1] is de ganse string P, en P[0..i] is een prefix van P. Als i > j, 

dan definiëren we P[i.. j] als de lege string ε (dit is de unieke string van lengte 0). We schrijven 

ook P[i] voor P[i..i], zodat P[0] de eerste en P[m − 1] de laatste letter van P is. 

In het eenvoudigste geval is de tekst een document in het computergeheugen (bijvoorbeeld in 

een tekstverwerker) en het patroon is een woord dat men in dit document wil localiseren. Dit 

is de klassieke versie van het “text searching” probleem, dat door een brute-kracht-algoritme in 

O(|P| × |T|) sequentiële tijd kan opgelost worden. We bespreken dit algoritme in Paragraaf 1.1. 

In Paragraaf 1.2 bespreken we de oplossing van Rabin-Karp, die gemiddelde uitvoeringstijd 

O(|P|+|T|) heeft. Deze oplossing gebruikt de techniek van hashing, hier “fingerprinting” genoemd. 

Het klassieke probleem kan opgelost worden in O(|P| + |T|) uitvoeringstijd. De twee meest 

gekende algoritmen die dit verwezenlijken zijn het algoritme van Knuth-Morris-Pratt (zie Paragraaf 

1.3) en het algoritme van Boyer-Moore (zie Paragraaf 1.4). Het implementeren van het 

algoritme van Boyer-Moore is echter ingewikkeld, zodat hiervoor een variant ontwikkeld is, het 

zogenaamde algoritme van Boyer-Moore-Horspool (zie ook Paragraaf 1.4). Dit algoritme heeft 

een slechtste-geval-uitvoeringstijd O(|P| × |T |), maar werkt in de praktijk zeer snel en is ook 

eenvoudig te implementeren. 

1.1 Een eenvoudig brute-kracht-algoritme 

Beschouw een tekstverwerker die een woord (of een frase) in een document moet zoeken. Een 

eenvoudige benadering localiseert het woord door het letter per letter te vergelijken met de tekst, 

daarbij alle mogelijke posities in de tekst proberend. Algoritme 1.1 implementeert dit idee. 

Stelling 1.1.1. Het brute-kracht-algoritme 1.1 vindt de correcte match van een patroon in een 

tekst (wanneer die bestaat) in uitvoeringstijd O(m(n − m+1)). 

Om te argumenteren dat het algoritme correct werkt, moeten we nagaan dat het patroon gecontroleerd 

wordt op alle mogelijke posities in de tekst. Aangezien het patroon m karakters bevat, is 

de laatst mogelijke positie voor P in T = [0..n − 1] gegeven door T[n − m..n − 1]. De buitenste 

while-lus probeert alle mogelijke indices van 0 t.e.m. n − m. 

Algoritmen en Datastructuren III Veerle.Fack@UGent.be

1.2. Het algoritme van Rabin-Karp 3 

Algoritme 1.1 (Brute-kracht-algoritme) Zoeken naar een patroon P in een tekst T 

Input: patroon P van lengte m, tekst T van lengte n 

Output: de kleinste index i zodanig dat T[i..i+m−1] = P, of −1 wanneer P niet optreedt in T 

1: Stel i ← 0 

2: while i+m ≤ n do 

3: Stel j ← 0 

4: while T[i+ j] = P[ j] do 

5: Stel j ← j+ 1 

6: if j ≥ m then 

7: return i 

8: Stel i ← i+1 

9: return −1 

In het slechtste geval is er geen overeenstemming voor het patroon in de tekst, en dan heeft het 

algoritme een Θ(m(n−m+1)) uitvoeringstijd. In het beste geval wordt het patroon aan het begin 

van de tekst gevonden, en dan is de uitvoeringstijd Θ(m). 

In de praktijk gedraagt het algoritme zich beter dan O(m(n−m+1)), omdat de binnenste whilelus 

een niet-overeenstemmend patroon behoorlijk snel herkent. Men kan bewijzen dat, voor 

willekeurige patronen en teksten, de uitvoeringstijd O(n − m) is (zonder bewijs). 

Dit eenvoudige algoritme kan zeer inefficiënt worden voor langere patronen, in het bijzonder 

wanneer in het patroon en de tekst stukken voorkomen die zich herhalen. De uitvoeringstijd 

kan O(n 2 ) worden, bv. wanneer m = n/2. Onze uiteindelijke bedoeling is het ontwikkelen van 

een algoritme dat in het slechtste geval lineaire uitvoeringstijd O(n + m) heeft. Een dergelijk 

algoritme geven we in Paragraaf 1.3. In de volgende paragraaf bespreken we een algoritme dat 

een gemiddelde O(n+m) uitvoeringstijd heeft. 

1.2 Het algoritme van Rabin-Karp 

In dit geval beperken we ons tot het binaire alfabet Σ = {0,1}. Het centrale idee achter het algoritme 

van Rabin-Karp is het volgende: vooraleer we tijd spenderen om effectief te controleren of 

een lang patroon op een bepaalde positie optreedt (dit kan m stappen vereisen), proberen we eerst 

door enkele eenvoudige testen na te gaan of we het gegeven patroon op de gegeven positie kunnen 

verwachten. Veronderstel dat we een dergelijke test in een goedkope O(1) tijd kunnen uitvoeren, 

en dat we kunnen verwachten daarmee alle behalve 1/m-de van de posities te elimineren, m.a.w. 

we houden (n−m+1)/m posities over waarvoor we effectief de O(m) brute-kracht-vergelijking 

moeten doorvoeren. Dit levert gezamelijke uitvoeringstijd O(m(n − m+1)/m) voor de vergelijkingen. 

Samen met de O(m) tijd voor de voorafgaande testen, geeft dit aanleiding tot een totale 

gemiddelde uitvoeringstijd van O(n+m). 

Hoe kunnen we nu snel bepaalde posities elimineren? Veronderstel bijvoorbeeld dat we zoeken 

naar het patroon P = “000011” in de tekst T = “0000010000100000”. Het patroon (van lengte 6) 



heeft pariteit 2 (een even aantal 1-en). In de tekst daarentegen heeft elke deelstring van lengte 6 

pariteit 1, behalve “100001”. Van de 11 = 16 − 6 + 1 posities in de tekst kunnen we er 10 

elimineren, simpelweg omdat ze de verkeerde pariteit hebben. Rabin en Karp noemden deze 

methode fingerprinting, omdat we niet het volledige patroon vergelijken maar slechts één klein 

aspect ervan (zijn vingerafdruk). 

We kunnen dus het eenvoudige algoritme uitbreiden om eerst een pariteitscontrole te doen en 

posities met de verkeerde pariteit over te slaan. Een rechtlijnige implementatie van dit idee zal 

echter niet tot een verbeterde uitvoeringstijd leiden, omdat het berekenen van de pariteit van 

m bits ook m stappen vraagt, terwijl we eisen dat de test in constante tijd gebeurt. We kunnen dit 

echter als volgt bekomen. Bij het begin van het algoritme bepalen we de pariteit van P en van 

de eerste m bits van de tekst, nl. T[0..m − 1]; dit vraagt O(m) tijd. Voor elke stap i > 0 hebben 

we de pariteit van T[i..i+m−1] berekend, zodat we in de volgende stap i+1 de pariteit van 

T[i+1..i+m] kunnen berekenen door enkel de bits T[i] en T[i+m] bekijken. Immers, zij x de 

pariteit van T[i..i+m−1], dan bekomen we de pariteit van T[i+1..i+m] als 

x+(T[i]+T[i+m])mod 2. 

De totale tijd besteed aan de voorafgaande tests voor een tekst van lengte n is dus O(n), of 

uitgemiddeld O(1) per test. 

Gemiddeld kunnen we verwachten dat de pariteitscontrole de helft van de posities elimineert, 

zodat de lus ongeveer m(n − m + 1)/2 stappen heeft. Dit is echter nog steeds Θ(m(n − m + 

1)). Pariteitscontrole alleen is dus niet voldoende om het algoritme op de gewenste manier te 

versnellen. De reden hiervoor is dat teveel waarden dezelfde vingerafdruk delen. Wanneer we 

een versnellingsfactor van q willen bekomen, dan moeten we een vingerafdrukfunctie vinden die 

(a) bitstrings van lengte m op q verschillende waarden (vingerafdrukken) afbeeldt; 

(b) de bitstrings van lengte m gelijkmatig verdeelt over de q vingerafdrukken; 

(c) gemakkelijk “in sequentie” te berekenen is. Hiermee bedoelen we dat, bij wijzigen van de 

string met 1 bit enkel aan het begin en het einde, de nieuwe vingerafdruk in O(1) tijd te 

berekenen is. 

Pariteitscontrole voldoet aan alle voorwaarden voor q = 2, hetgeen verklaart waarom dit een 

versnellingsfactor 2 geeft. 

Een functie die aan voorwaarden (a) en (b) voldoet, is een hashfunctie. Deze voorwaarden zijn 

nodig omdat ze impliceren dat gemiddeld (q − 1)/q van de waarden geëlimineerd worden, zodat 

het brute-kracht-algoritme slechts op 1/q van de posities moet uitgevoerd worden. Dit betekent, 

voor (n − m+1)/q posities, een vergelijking die O(m) tijd kost, en dus in totaal een tijd m(n − 

m+1)/q. Wanneer we q groter dan m kiezen, is dit O(n). 

Voorwaarde (c) garandeert dat we in constante tijd kunnen beslissen of een positie geëlimineerd 

kan worden. Het elimineren van de posities kost dus in totaal O((n − m + 1)(q − 1)/q) tijd, 


1.2. Het algoritme van Rabin-Karp 5 

hetgeen O(n) is. Brengen we ook de O(m) voorbereidingstijd in rekening, dan komen we een 

gemiddelde tijd van O(n+m). 

Hoe vinden we een functie die voldoet aan voorwaarden (a), (b) en (c) voor q > m? Naar analogie 

met de pariteitscontrole, is een eerste idee het bepalen van de som van de m bits. Deze functie 

voldoet aan voorwaarden (a) en (c), maar niet aan voorwaarde (b), want er is bv. maar één string 

die als waarde 0 of m geeft. 

Rabin en Karp suggereerden de volgende hashfunctie: beschouw de m bits als de binaire voorstelling 

van een natuurlijk getal en neem de rest bij deling door q. Zij s0s1...sm−1 de m bits, dan 

berekenen we de hashwaarde als 

m−1 

∑ s j2 

j=0 

m−1− j mod q. 

Deze functie voldoet triviaal aan voorwaarde (a). Voorwaarde (b) hangt af van de waarde van q. 

Voor willekeurige patronen en teksten is de waarde van q weinig belangrijk, maar in de praktijk 

moeten bepaalde q-waarden vermeden worden. Bijvoorbeeld, veronderstel dat de teksten bestaan 

uit ongeveer 30% 1-en en 70% 0-en, en dat q = 2 en m = 2. Dan verwachten we dat de meeste 

substrings van de vorm 00 zullen zijn, en dat 01, 10 en 11 veel minder voorkomen. Er zijn dus 

veel meer substrings met vingerafdruk 0 dan met vingerafdruk 1. In de praktijk blijkt de keuze 

van een priemgetal voor q > m goed te werken, en aan voorwaarde (b) te voldoen. 

Vervolgens gaan we na of voorwaarde (c) voldaan is. Beschouw m+1 bits s0s1...sm−1sm. De 

eerste m bits krijgen als vingerafdruk a = ∑ m−1 

j=0 s j2m−1− j mod q. De bits s1...sm krijgen als 

vingerafdruk 

m−1 

∑ s j+12 

j=0 

m−1− j mod q 

m−2 

= sm + ∑ s j+12 

j=0 

m−1− j mod q 

m−2 

= sm + 2 

∑ 

j=0 

s j+12 m−1−( j+1) mod q 

m−1 

= sm + 2 s j2 m−1− j mod q 

= sm + 2 

∑ 

j=1 

 

−2 m−1 s0 + 

= sm + 2(a − 2 m−1 s0)mod q. 

 

m−1 

m−1− j 

∑ s j2 mod q 

j=0 

Gebruik makend van deze formule kan de volgende vingerafdruk uit de voorgaande berekend 

worden in constante tijd. Merk op dat 2 m−1 best eenmaal vooraf kan berekend worden, omdat 

deze waarde in elke stap gebruikt wordt. 

Algoritme 1.2 geeft de pseudocode voor het algoritme van Rabin-Karp. 

Stelling 1.2.1. Het algoritme van Rabin-Karp vindt de correcte match van een patroon in een 

tekst (wanneer die bestaat) in uitvoeringstijd O(m(n − m+1)). 



Algoritme 1.2 (Rabin-Karp) Zoeken naar het voorkomen van een patroon P in een tekst T 



1: Stel q ← een priemgetal > m 

2: Stel r ← 2 m−1 mod q 

3: Bereken fp ← ∑ m−1 

j=0 P[ j]2m−1− j mod q 

4: Bereken ft[0] ← ∑ m−1 

j=0 T[ j]2m−1− j mod q 

5: Stel i ← 0 


7: if ft[i] = fp then 

8: if T[i..i+m−1] = P then 

9: return i 

10: Stel ft[i+1] ← 2 ×(ft[i] − r × T[i])+T[i+m]mod q 

11: Stel i ← i+1 


1.3 Het algoritme van Knuth-Morris-Pratt 

In deze paragraaf bespreken we het algoritme van Knuth-Morris-Pratt, dat het string-matchingprobleem 

oplost in O(|P|+|T|) tijd. Maar eerst bekijken we aan de hand van enkele voorbeelden 

waarom het eenvoudige brute-kracht-algoritme inefficiënt kan zijn. 

1.3.1 Inefficiëntie van het brute-kracht-algoritme 

Voorbeeld 1.3.1. Veronderstel dat we zoeken naar een patroon P = tweedledum in een tekst 

T = tweedledee and tweedledum en dat we de volgende situatie bereikt hebben: 

tweedledee and tweedledum 

tweedledu 

Op dit moment zouden we het patroon P één plaats opschuiven tegenover de tekst en opnieuw 

beginnen controleren. We kunnen echter reeds weten dat tweedledum niet op de tweede positie 

kan voorkomen, omdat de tekst begint met tweedled. In het bijzonder bevat tweedled geen 

enkele t na de eerste, zodat we het patroon in de tekst kunnen opschuiven tot de eerste letter na 

tweedled in de tekst en vanaf daar het controleren verderzetten: 

tweedledee and tweedledum 

tweedledu 

Voorbeeld 1.3.2. Als tweede voorbeeld beschouwen we het zoeken van patroon P = pappar 

in tekst T = pappappapparrassanuaragh. 


1.3. Het algoritme van Knuth-Morris-Pratt 7 

pappappapparrassanuaragh 

pappar 

Na 6 vergelijkingen bekomen we een conflict tussen de r op het einde van P en de p op de 

corresponderende positie in T . Het eenvoudige algoritme begint dan met het patroon te matchen 

tegenover T[1] = a. Maar hier hadden we reeds pappa tegenover de tekst gematcht, m.a.w. 

T[0..4] = pappa en we kunnen we het patroon 3 posities vooruit schuiven: 

pappa................... 

pappar 

Bovendien weten we dat P[0..1] = T[3..4] en kunnen we dus het zoeken verderzetten vanaf T[5], 

m.a.w. vanaf dezelfde positie in de tekst waar de mismatch optrad: 

pappappapparrassanuaragh 

pappar 

1.3.2 Gebruik van een verschuivingstabelvoor het patroon 

Algemeen kunnen we, voor een gegeven patroon P, een tabel opstellen die voor elke k het antwoord 

op de volgende vraag bijhoudt: Wanneer P[0..k] de tekst matcht en P[k + 1] niet, over 

hoeveel posities kunnen we het patroon dan opschuiven? Hoe de tabel opgesteld kan worden, 

bespreken we later. 

Voorbeeld 1.3.3. De tabel voor P = tweedledum is: 

t w e e d l e d u m 

k −1 0 1 2 3 4 5 6 7 8 9 

S 1 1 2 3 4 5 6 7 8 9 10 

Merk op dat in dit geval S[k] = max{1,k + 1}. Het is gemakkelijk in te zien dat, wanneer we 

P[0..k] gematcht hebben tegenover T[i..i+k], maar P[k+1] = T[i+k+1], er geen match voor P 

kan zijn startend op posities i t.e.m. i+k in T . Immers, er kan geen match zijn op positie i, want 

we hebben net vastgesteld dat P[k+ 1] = T[i+k+ 1]. Bovendien zijn er geen matches mogelijk 

op posities i+1 t.e.m. i+k, want daar staan dezelfde karakters als P[1..k], en dus bevattten ze 

geen t, waarmee een match met P moet beginnen. We kunnen het patroon dus opschuiven tot 

positie i+k+ 1 in de tekst en beginnen met het vergelijken van P[0] en T[i+k+ 1]. In het geval 

dat k = −1 weten we dat P[0] = T[1], zodat we het patroon naar de volgende positie opschuiven. 

Wanneer dus het zoeken van tweedledum in tweedledee and tweedledum faalt op 

P[8], dan gebruiken we S[7] om te bepalen dat we het patroon over 8 posities mogen verschuiven. 

De volgende vergelijking is P[0] = t tegenover T[8] = e. 

Voorbeeld 1.3.4. De tabel voor P = pappar is: 



p a p p a r 

k −1 0 1 2 3 4 5 

S 1 1 2 2 3 3 6 

Veronderstel dat we het patroon P = pappar zoeken in de tekst T = panther. Bij de mismatch 

van P[2] tegenover de n in panther kunnen we patroon verschuiven over S[1] = 2 posities en 

verdergaan met het vergelijken van P[0] = p met T[2] = n: 

panther panther 

pappar pappar 

- - 

Bij het zoeken van P = pappar in T = papaya tree, kunnen we bij de mismatch van P[3] 

het patroon verschuiven over S[2] = 2 posities, en verdergaan met het vergelijken van P[1] = a 

met T[3] = a (d.i. de positie in de tekst waar de mismatch optrad): 

papaya tree papaya tree 

pappar pappar 

- - 

Bekijken we tenslotte het zoeken van P = pappar in de tekst T = pappappapparrassanua: 

pappappapparrassanua 

pappar 

- 

Na 6 vergelijkingen weten we dat P[0..4] = T[0..4] en P[5] = T[5]. We verschuiven het patroon 

over S[4] = 3 posities en vervolgen met het vergelijken van P[2] met T[5]: 


pappar 

- 

Na nog 4 vergelijkingen vinden we een mismatch P[5] = T[8], waardoor we het patroon mogen 

verschuiven over S[4] = 3 posities en verderzoeken in de tekst vanaf T[8], te vergelijken met P[2]: 


pappar 

- 

Na nog eens 4 vergelijkingen vinden we een match voor het patroon in de tekst. 



Algoritme 1.3 (Knuth-Morris-Pratt) Zoeken naar een patroon P in een tekst T 



1: Bereken de verschuivingstabel S 

2: Stel i ← 0 en j ← 0 



5: Stel j ← j+ 1 

6: if j ≥ m then 

7: return i 

8: Stel i ← i+S[ j − 1] 

9: Stel j ← max(0, j − S[ j − 1]) 


Algemeen kunnen we het gebruik van de verschuivingstabel als volgt argumenteren. Veronderstel 

dat P[0..k], m.a.w. het patroon t.e.m. positie k, de karakters in de tekst startend op positie i 

matcht, m.a.w. P[0..k] = T[i..i+k]. We beschouwen het verschuiven van het patroon over s posities. 

Opdat de verschuiving mogelijk zou zijn, moeten de eerste k − s+1 karakters van P de 

tekst op de nieuwe positie matchen: 

P: 0 1 2 . . . s s+1 s+2 . . . k . . . 

T : 0 . . . i i+1 i+2 . . . i+s i+s+1 i+s+2 . . . i+k . . . i+s+k 

P: 0 1 2 . . . k − s . . . k 

Uit het bovenstaande diagram blijkt dat, opdat de verschuiving mogelijk zou zijn, er moet gelden 

dat P[0..k − s] = T[i + s..i+ k]. We weten echter ook dat T[i + s..i+k] = P[s..k]. Dus moet 

P[0..k − s] = P[s..k]. Dit is de voorwaarde opdat een verschuiving mogelijk zou zijn. Om geen 

mogelijke match te missen, moeten we de kleinste van dergelijke verschuivingen beschouwen. 

M.a.w. 

S[k] = min{s > 0 | P[0..k − s] = P[s..k]}. 

We vereisen s > 0 omdat we een effectieve verschuiving willen bekomen. Het beste geval treedt 

op wanneer er geen enkele match is en s = k + 1 (in dat geval zijn P[0..k − s] en P[s..k] beiden 

leeg en dus gelijk). 

1.3.3 Het algoritme van Knuth-Morris-Pratt 

Algoritme 1.3 geeft de pseudocode voor het algoritme van Knuth-Morris-Pratt. Veronderstellen 

we voorlopig dat het berekenen van de verschuivingstabel correct gebeurt in tijd O(m) (we 

bespreken later hoe dit kan). Om de correctheid van het algoritme van Knuth-Morris-Pratt te 

bewijzen, moeten we aantonen dat bovenstaande intuïtieve beschrijving van het gebruik van de 



verschuivingstabel correct is, m.a.w. dat de verschuivingstabel ons de volgende mogelijke positie 

voor een match geeft, zonder tussenliggende matches over te slaan. Dit wordt bewezen in de 

volgende stelling. 

Stelling 1.3.5. Veronderstel dat P[0.. j − 1] = T[i..i+ j − 1] en P[ j] = T[i+ j], m.a.w. we hebben 

een gedeeltelijke match van patroon P die op positie i + j in T faalt. Zij i ′ = i + S[ j − 1] en 

j ′ = max{0, j − S[ j − 1]}. Dan geldt: 

(a) P[0.. j ′ − 1] = T[i ′ ..i ′ + j ′ − 1], en 

(b) P = T[k..k+ m − 1] voor alle i ≤ k 

M.a.w. P[0.. j ′ − 1] matcht T startend op positie i ′ , en er zijn geen matches voor P op posities 

i,i+1,...,i ′ − 1. 

Bewijs. Bij definitie is S[ j − 1] een toegelaten verschuiving, nl. 

Dus 

P[0.. j − 1 − S[ j − 1]] = P[S[ j − 1].. j − 1]. 

P[0.. j ′ − 1] = P[0.. j − 1 − S[ j − 1]] per definitie van j ′ 

= P[S[ j − 1].. j − 1] per definitie van S[ j − 1] 

= T[i+S[ j − 1]..i+ j − 1] want P[0.. j − 1] = T[i..i+ j − 1] 

= T[i ′ ..i ′ + j ′ − 1] per definitie van i ′ en j ′ 

Dit bewijst (a). Om (b) te bewijzen moeten we aantonen dat S[ j − 1] de kleinste toegelaten 

verschuiving is en dat we geen mogelijke matches missen door de verschuiving uit te voeren. 

We bewijzen dit uit het ongerijmde. Onderstel dat P[0..m − 1] = T[k..k + m − 1] voor zekere 

i ≤ k 

P[0.. j − 1 − k ′ ] = T[k..k+ j − 1 − k ′ ] bij veronderstelling 

= T[k..i+ j − 1] per definitie van k ′ 

= P[k ′ .. j − 1] want P[0.. j − 1] = T[i..i+ j − 1] 

Dus is k ′ ≥ S[ j − 1], wegens definitie van S[ j − 1], hetgeen strijdig is met de veronderstelling dat 

k ′ = k − i 

Stelling 1.3.6. De uitvoeringstijd van het algoritme van Knuth-Morris-Pratt is Θ(m+n). 

Bewijs. De buitenste lus (op lijn 3) wordt hoogstens n keer uitgevoerd, want i wordt in elke iteratie 

verhoogd, omdat de verschuivingstabel enkel strikt positieve waarden bevat. De binnenste 

lus (op lijn 4) zou echter m stappen kunnen hebben, hetgeen zou leiden tot een bovengrens op de 

uitvoeringstijd van O(nm), hetgeen niet aanvaardbaar is. 

Om het totale aantal stappen in beide lussen beter in te schatten, beschouwen we de evolutie 

van de waarde 2i+ j tijdens de uitvoering van lijn 4 van het algoritme. Wanneer de vergelijking 



Algoritme 1.4 (Knuth-Morris-Pratt verschuivingstabel) Opbouwen van de verschuivingstabel 

voor het algoritme van Knuth-Morris-Pratt 

Input: patroon P van lengte m 

Output: de verschuivingstabel S 

1: Stel S[−1] ← 1 

2: Stel S[0] ← 1 

3: Stel i ← 1 en j ← 0 

4: while i+ j < m do 

5: if P[i+ j] = P[ j] then 

6: Stel S[i+ j] ← i 

7: Stel j ← j+ 1 

8: else 

9: if j = 0 then 

10: Stel S[i] ← i+1 

11: Stel i ← i+S[ j − 1] 

12: Stel j ← max(0, j − S[ j − 1]) 

T[i+ j] = P[ j] true levert, wordt j met 1 verhoogd, en dus ook 2i+ j. Wanneer de vergelijking 

false levert, wordt S[ j − 1] opgeteld bij i en hoogstens S[ j − 1] afgetrokken van j, m.a.w. 2i+ j 

verhoogt met minstens S[ j − 1] ≥ 1. Dus elke keer wanneer het algoritme terugkeert naar de test 

op lijn 4 is de waarde van 2i+ j verhoogd. Aangezien 2i+ j ≤ 2n+m, kan dit hoogstens 2n+m 

keer gebeuren, hetgeen een bovengrens van O(n+m) voor de lus levert. 

Aangezien we veronderstellen dat de initialisatie tijd O(m) vraagt, levert dit dus een totale uitvoeringstijd 

voor het algoritme van O(n+m). 

1.3.4 Berekenen van de verschuivingstabel 

Tenslotte bekijken we hoe de verschuivingstabel kan opgesteld worden in O(m) tijd. Het idee is 

hetzelfde als voor het zoeken van een patroon in een tekst, met als verschil dat we nu het patroon 

in zichzelf proberen te lokaliseren. 

Veronderstel dat we algoritme 1.3 uitvoeren met T = P. Telkens wanneer we j in de binnenste lus 

incrementeren hebben we een gedeeltelijke match P[0.. j] = P[i..i+ j] gevonden. Dit impliceert 

dat S[i+ j] ≤ i, want 

S[i+ j] = min{s > 0 | P[0..i+ j − s] = P[s..i+ j]}. 

Anderzijds weten we ook dat deze manier van werken gegarandeerd geen matches mist, zodat 

we kunnen stellen dat S[i+ j] = i en we kunnen deze waarde in de tabel invullen. 

Algoritme 1.4 implementeert dit idee. Merk op dat tijdens het algoritme enkel waarden uit de 

verschuivingstabel gebruikt worden die reeds eerder ingevuld werden. 



Algoritme 1.5 (Boyer-Moore) Zoeken naar een patroon P in een tekst T (eenvoudige versie) 



1: Stel i ← 0 


3: Stel j ← m − 1 


5: Stel j ← j − 1 

6: if j < 0 then 

7: return i 

8: Stel i ← i+1 


1.4 Het algoritme van Boyer-Moore-Horspool 

Boyer en Moore kwamen op het volgende schijnbaar onschuldige idee: waarom niet proberen 

om het patroon van rechts naar links met de tekst te vergelijken in plaats van van links naar 

rechts, maar wel de richting van de verschuiving behouden? Bijvoorbeeld, een herimplementatie 

van het eenvoudige Algoritme 1.1 levert Algoritme 1.5. 

Dit algoritme vereist ook O(mn) uitvoeringstijd, maar het is wel zeer geschikt voor het implementeren 

van twee heuristieken die het algoritme significant zullen versnellen. 

1.4.1 De occurrence-heuristiek 

We bekijken enkele voorbeelden van de occurrence-heuristiek. 

Voorbeeld 1.4.1. Veronderstel dat we het patroon rum zoeken in de tekst conumdrum. Met de 

Boyer-Moore-versie van het eenvoudige algoritme zullen we eerst de m van rum vergelijken met 

de n van conumdrum: 

conumdrum 

rum 

Deze vergelijking faalt uiteraard, en bovendien weten we dat het patroon rum de letter n niet 

bevat, zodat we het patroon kunnen verschuiven over 3 posities: 

conumdrum 

rum 

Hier zien we dat m niet matcht met d, en we weten dat het patroon geen d bevat, zodat we de het 

patroon weer over 3 posities kunnen verschuiven: 


1.4. Het algoritme van Boyer-Moore-Horspool 13 

conumdrum 

rum 

Hier vinden we uiteindelijk een match. 

Voorbeeld 1.4.2. Als tweede voorbeeld zoeken we naar het patroon drum in de tekst conundrum: 

conundrum 

drum 

Opnieuw hebben we een mismatch, maar dit keer komt de letter u uit de tekst wel in het patroon 

voor. We kunnen dus het patroon over 1 positie verschuiven, namelijk zodanig dat de (meest 

rechtse) u uit het patroon drum gealigneerd wordt met de u (op de positie van de mismatch) in 

de tekst conundrum: 

conundrum 

drum 

De mismatch tussen m en n leidt nu tot het verschuiven over 4 posities: 

conundrum 

drum 

Dit levert de uiteindelijke match. 

Voorbeeld 1.4.3. Als laatste voorbeeld bekijken we het zoeken van het patroon natu in de tekst 

conundrum: 

conundrum 

natu 

De match van t en n faalt, zodat we het patroon verschuiven zodanig dat de n uit patroon en 

tekst elkaar matchen: 

conundrum 

natu 

Hier faalt de match van t en n, en natu bevat geen d, zodat we het patroon voorbij de d in de 

tekst moeten schuiven. Maar aangezien er in de tekst slechts drie karakters voorbij d overblijven, 

weten we dat het patroon niet in de tekst optreedt. 



We kunnen de occurrence-heuristiek als volgt samenvatten: Vergelijk het patroon met de tekst 

van rechts naar links. Wanneer een mismatch van een karakter α uit de tekst optreedt, verschuif 

het patroon zodanig dat het meeste rechtse voorkomen van α in het patroon gealigneerd wordt 

op α van de mismatch in de tekst. Indien het patroon geen α bevat, verschuif het patroon dan tot 

de positie voorbij α in de tekst. 

Er is echter een subtiel probleem met deze heuristiek: het zou kunnen gebeuren dat het patroon 

terug naar links verschoven wordt in plaats van naar rechts, wanneer het meest rechtse voorkomen 

van α reeds voorbij de huidige positie geschoven is. De oplossing die Boyer en Moore 

voorstelden, is om dergelijke gevallen het patroon over 1 positie naar rechts te verschuiven. 

Voorbeeld 1.4.4. We zoeken het patroon date in de tekst detective: 

detective 

date 

We krijgen een mismatch bij a en e, hetgeen zou leiden tot de volgende verschuiving: 

detective 

date 

Dit zou dus betekenen dat het patroon verschoven wordt naar een positie die reeds eerder behandeld 

werd, m.a.w. een negatieve verschuiving. We verschuiven het patroon dus over 1 positie 

naar rechts: 

detective 

date 

1.4.2 De match-heuristiek 

De tweede heuristiek is analoog aan het idee gebruikt in het algoritme van Knuth-Morris-Pratt: 

Wanneer een match-proces halverwege faalt, dan kunnen we informatie over het stuk tekst dat we 

tot dan toe gezien hebben, gebruiken om het patroon naar de volgende mogelijke match te schuiven. 

Aangezien we echter van rechts naar links vergelijken, moeten we de verschuivingstabel 

voor het achterstevoren patroon berekenen. 

Voorbeeld 1.4.5. We gebruiken de match-heuristiek om het patroon P = banana in de tekst 

T = a banana te zoeken: 

a banana 

banana 



We vinden een match voor P[3..5] = ana met T[3..5] = ana, en vervolgens een mismatch voor 

P[2] = n met T[2] = b. De Knuth-Morris-Pratt-verschuivingstabel voor ananab levert S[3] = 2, 

zodat we P over twee posities naar rechts kunnen verschuiven: 

a banana 

banana 

Op dit punt vinden we een match. 

1.4.3 Het algoritme van Boyer-Moore-Horspool 

Het algoritme van Boyer-Moore implementeert deze beide heuristieken, en kiest diegene die 

aanleiding geeft tot de grootste verschuiving. Zodoende wordt het algoritme een van de snelste 

algoritmen voor string-matching, zowel in theorie als in de praktijk. De match-heuristiek garandeert 

een uitvoeringstijd van O(m+n), zoals in het Knuth-Morris-Pratt-algoritme, en er zijn 

heel wat verbeteringen om het effectieve aantal vergelijkingen te verminderen. Het is echter een 

behoorlijk complex algoritme om te implementeren, vooral door de match-heuristiek. Dit is de 

reden dat we hier een variante beschouwen die voorgesteld werd door Horspool, en die gekend 

is als het algoritme van Boyer-Moore-Horspool. Dit algoritme implementeert een gewijzigde 

occurrence-heuristiek en is zeer snel in de praktijk, alhoewel zijn slechtste-geval-uitvoeringstijd 

O(mn) is. 

We hebben reeds eerder een subtiel probleem vermeld dat kon optreden bij de occurrenceheuristiek, 

nl. dat het tot negatieve verschuivingen (verschuivingen naar links) kan leiden wanneer 

het meest rechtse voorkomen van het karakter reeds rechts van de huidige positie is. Merk 

op dat dit geval zich enkel voordoet wanneer we reeds een gedeelte van het patroon gematcht 

hebben. Beschouw het geval waarbij het laatste karakter een mismatch geeft; in dat geval verschuiven 

we altijd naar rechts. Horspool stelde voor om de verschuiving steeds te bepalen uit het 

laatste karakter, en niet uit het karakter dat zorgt voor de mismatch. Hierdoor worden negatieve 

verschuivingen vermeden. 

Voorbeeld 1.4.6. In het geval van 

detective 

date 

faalt de match bij P[1] = a en T[1] = e. We verschuiven dan het patroon zodanig dat de laatste 

letter T[3] gealigneerd wordt met de volgende mogelijke match in P. Aangezien date geen 

andere e bevat, kunnen we het volledige patroon opschuiven tot voorbij T[3] = e: 

detective 

date 

Hierdoor worden drie posities overgeslagen. 



Samenvattend, de reactie van het algoritme van Horspool op een mismatch bestaat erin te proberen 

T[i − m+1] te matchen met het meest rechtse optreden van dat karakter in het patroon links 

van P[m − 1]. Deze regel garandeert dat het patroon altijd naar rechts verschoven wordt. Om 

de verschuiving correct uit te voeren, moeten we voor elk karakter uit het alfabet weten wat zijn 

meest rechtse voorkomen in het patroon links van P[m − 1] is. Meer formeel: 

 

m − 1 − max{i < m − 1 | P[i] = x} als x behoort tot P[0..m − 2] 

S[x] = 

m anders 

Voorbeeld 1.4.7. Voor het woord P = kettle krijgen we de volgende verschuivingen: 

S[k] = 5; S[e] = 4; S[t] = 2; S[l] = 1. 

Voor elke andere letter is de waarde in de verschuivingstabel 6. 

Beschouw bijvoorbeeld de tekst T = tea kettle: 

tea kettle 

kettle 

De mismatch van P[4] = l en T[4] = k, leidt tot een verschuiving van S[T[5]] = S[e] = 4, en we 

vinden onmiddellijk de match: 

tea kettle 

kettle 

Beschouw bijvoorbeeld de tekst T = a kettle: 

a kettle 

kettle 

De mismatch van P[5] = e en T[5] = t leidt tot een verschuiving van S[T[5]] = S[t] = 2: 

a kettle 

kettle 

Opnieuw vinden we onmiddellijk een match. 

Algoritme 1.6 geeft de pseudocode voor het algoritme van Boyer-Moore-Horspool. 

Wanneer we veronderstellen dat het alfabet Σ vast is, dan loopt het algoritme van Boyer-Moore- 

Horspool in O(mn) tijd. In tegenstelling tot het volledige Boyer-Moore-algoritme en het algoritme 

van Knuth-Morris-Pratt hangt de gebruikte geheugenruimte van dit algoritme niet af van P. 

Inderdaad, de geheugencomplexiteit is O(|Σ|), m.a.w. constant indien we veronderstellen dat 

een vast alfabet gebruikt wordt. In de praktijk zijn de uitvoeringstijden van dit algoritme vergelijkbaar 

met die van het algoritme van Boyer-Moore. Hierdoor is het algoritme zeer bruikbaar, 

omdat het veel eenvoudiger te implementeren is en minder geheugenruimte gebruikt. 



Algoritme 1.6 (Boyer-Moore-Horspool) Zoeken naar een patroon P in een tekst T over een 

alfabet Σ 

Input: patroon P van lengte m, tekst T van lengte n, alfabet Σ 


1: {Berekenen van de verschuivingstabel} 

2: for k from 0 to |Σ| − 1 do 

3: Stel S[k] ← m 

4: for k from 0 to m − 2 do 

5: Stel S[P[k]] ← m − 1 − k 

6: {Zoeken} 

7: Stel i ← 0 


9: Stel j ← m − 1 


11: Stel j ← j − 1 

12: if j < 0 then 

13: return i 

14: Stel i ← i+S[T[i+m−1]] 





Hoofdstuk 2 

Algoritmen voor benaderend 

string-matching 

Door minder strenge eisen te stellen, ontstaan een aantal varianten van het klassieke probleem 

van string-matching. Men kan bijvoorbeeld matches toelaten die slechts benaderend zijn, waarbij 

natuurlijk moet gespecificeerd worden wat “benaderend” precies inhoudt. In dit hoofdstuk 

bestuderen we voorbeelden hiervan. 

Er zijn heel wat varianten van het probleem van benaderend string-matching, hetgeen de veelheid 

van situaties weerspiegelt waarin het zoeken van een patroon in een tekst gebaseerd is op 

onvolledige en/of imprecieze informatie. 

Beschouw bijvoorbeeld het vergelijken van twee bestanden op de computer om uit te vinden in 

hoeverre ze verschillen of wat er veranderd is in een nieuwe versie van een bestand. Dit is het 

soort bewerking uitgevoerd door het commando diff in Unix. Hoe kan diff nu weten of hij 

de juiste stukken tekst met elkaar vergelijkt, wanneer er meerdere mogelijkheden zijn? Uiteraard 

kan het commando dit niet weten, aangezien het niet weet wat het verband tussen de bestanden 

is. Een manier om dit probleem op te lossen is door het definiëren van een maat van verschil 

tussen twee bestanden als het aantal wijzigingen dat iemand zou moeten aanbrengen in het ene 

bestand om het andere bestand te bekomen. Het kleinste aantal nodige wijzigingen wordt de 

editeerafstand tussen de twee bestanden genoemd. Hiermee wordt ook een reeks bewerkingen 

geassocieerd die het ene bestand in het andere omzetten. 

Een ander voorbeeld is het zoeken naar een woord in een tekst, waarbij we echter niet helemaal 

zeker zijn dat het woord correct gespeld is. In dit geval willen we het zoekprogramma vertellen 

dat het moet zoeken naar tekst die sterk gelijkt op het patroon dat we ingeven. Het blijkt dat dit 

probleem nauw verwant is met het bovenstaande voorbeeld van het vergelijken van twee teksten. 

19

20 Hoofdstuk 2. Algoritmen voor benaderend string-matching 

2.1 Editeerafstand tussen strings 

De editeerafstand d(S,T) tussen twee strings S en T wordt gedefinieerd als het kleinste aantal 

editeerbewerkingen dat nodig is om S in T om te zetten. Als toegelaten editeerbewerkingen 

worden meestal de volgende bewerkingen beschouwd, elk met eenheidskost: 

• het vervangen van een karakter door een ander karakter; 

• het verwijderen van een karakter; 

• het tussenvoegen van een karakter. 

Voorbeeld 2.1.1. Beschouw het voorbeeld van het omzetten van het woord ghost in het woord 

house: 

g h o s t verwijder g op positie 0 

h o s t voeg u toe na positie 1 

h o u s t vervang t door e op positie 4 

Merk op dat we niet vereisen dat de tussenliggende woorden correcte Nederlandse of Engelse 

woorden zijn. De kost van deze reeks bewerkingen is 3. 

Merk op dat een woord S steeds in om het even welk ander woord T kan omgezet worden. In 

het slechtste geval verwijderen we alle letters van S en voegen vervolgens alle letters van T toe. 

M.a.w. 

d(S,T) ≤ |S|+|T|. 

Het berekenen van de afstand tussen twee strings kan op natuurlijke wijze gebeuren m.b.v. de 

techniek van dynamisch programmeren (zie cursus “Algoritmen en Datastructuren II”). 

Als deelproblemen bij het berekenen van de afstand d(S,T) berekenen we eerst de afstanden 

van de prefixen van S en T , m.a.w. d(S[0..i],T[0.. j]), voor alle 0 ≤ i < |S| en alle 0 ≤ j < |T|. 

Definiëren we als di, j = d(S[0..i],T[0.. j]). De afstand tussen S en T is dan d(S,T) = d |S|−1,|T|−1. 

Voorbeeld 2.1.2. Hierna volgt de tabel van afstanden voor de woorden S = presto en T = 

peseta: 

0 1 2 3 4 5 

p e s e t a 

0 p 0 1 2 3 4 5 

1 r 1 1 2 3 4 5 

2 e 2 1 2 2 3 4 

3 s 3 2 1 2 3 4 

4 t 4 3 2 2 2 3 

5 o 5 4 3 3 3 3 


2.1. Editeerafstand tussen strings 21 

Bijvoorbeeld, d(S[0],T[0]) = 0, omdat ze beiden dezelfde letter zijn, nl. p. Dan is d(S[0],T[0.. j]) = 

j, omdat de snelste manier om p om te zetten in een prefix T[0.. j] van peseta erin bestaat 

de j letters van T[1.. j] toe te voegen. Op analoge manier kunnen we argumenteren dat 

d(S[0..1],T[0.. j]) = j, voor alle j ≥ 1, omdat we r kunnen vervangen door e, en vervolgens de 

letters van T[2.. j] toevoegen. Merk op dat d(S[0..1],T[0]) = 1, omdat de snelste manier om pr 

om te zetten in p bestaat uit het verwijderen van r. 

Hoe kunnen we nu algemeen de afstanden tussen S[0..i] en T[0.. j] berekenen? We beginnen met 

het einde van de deelstrings te bekijken: hoe is S[i], de laatste letter van S[0..i], tot T[ j], de laatste 

letter van T[0.. j] geworden? Er zijn drie mogelijke operaties die hiertoe kunnen geleid hebben: 

• Vervangen van S[i] door T[ j], en omzetten van S[0..i − 1] tot T[0.. j − 1]. Dit vraagt hoogstens 

1+di−1, j−1 bewerkingen. Immers, wanneer S[i] = T[ j] dan is geen effectieve vervanging 

nodig en gebeuren er slechts di−1, j−1 bewerkingen. 

• Verwijderen van S[i], en omzetten van S[0..i − 1] tot T[0.. j]. Dit vraagt 1+di−1, j bewerkingen. 

• Toevoegen van T[ j] aan het einde van S[0..i], en omzetten van S[0..i] tot T[0.. j − 1]. Dit 

vraagt 1+di, j−1 bewerkingen. 

Hieruit volgt dat we S[0..i] kunnen omzetten in T[0.. j] in 

⎧ 

⎪⎨ 

0 als S[i] = T[ j] 

di−1, j−1 + 

1 anders 

min 

⎪⎩ 

di, j−1 + 1 

di−1, j + 1 

stappen. Aangezien we alle mogelijkheden beschouwd hebben waarop S[i] in T[ j] kan omgezet 

worden, geeft dit ons de correcte waarde voor di, j. Uit de formule blijkt ook dat di, j kan berekend 

worden uit de waarden van di−1, j−1,di, j−1,di−1, j, m.a.w. uit de tabelwaarden in naburige 

plaatsen: linksboven (i − 1, j − 1), links (i, j − 1) en boven (i − 1, j). De eenvoudigste manier 

om dit te bekomen is door de tabel rij per rij te berekenen, startend in de linkerbovenhoek. 

Voorbeeld 2.1.3. Beschouwen we bijvoorbeeld de berekening van d3,2 in de bovenstaande tabel 

voor S = presto en T = peseta. Aangezien S[3] = T[2] is d3,2 het minimum van d2,1 = 1, 

d2,2 + 1 = 3 en d3,1 + 1 = 3. Dus d3,2 = 1. Beschouwen we vervolgens de berekening van d5,3. 

Omdat S[5] = T[3] is d5,3 het minimum van d4,2 + 1 = 3, d4,3 + 1 = 3 en d5,2 + 1 = 4. Dus 

d5,3 = 3. 

Nu we de recursieve formule voor het bepalen van di, j opgesteld hebben, bekijken we opnieuw 

de tabel. Hoe zijn we daar van start gegaan? In rij 0 pasten we eigenlijk de recursieve formule al 

toe op een onzichtbare rij −1. Voegen we een rij en kolom −1 toe aan de tabel. De waarde van 

d−1, j moet het kleinste aantal editeerbewerkingen zijn dat S[0.. − 1] (d.i. de lege string) omzet 

in T[0.. j]. Merk op dat we de lege string in T[0.. j] kunnen omzetten door de j + 1 tekens van 



Algoritme 2.1 Opstellen van de tabel met de editeerafstanden tussen de prefixen van twee strings 

Input: string S van lengte m, string T van lengte n 

Output: d(S,T) 

1: {Initialiseren van kolom −1} 

2: for i from −1 to m − 1 do 

3: Stel d[i,−1] ← i+1 

4: {Initialiseren van rij −1} 

5: for j from 0 to n − 1 do 

6: Stel d[−1, j] ← j+ 1 

7: {Berekening van de eigenlijke tabel} 

8: for i from 0 to m − 1 do 


10: if S[i] = T[ j] then 

11: Stel x ← d[i − 1, j − 1] 

12: else 

13: Stel x ← 1+d[i − 1, j − 1] 

14: Stel d[i, j] ← min(x,1+d[i, j − 1],1+d[i − 1, j]) 

15: return d[m − 1,n − 1] 

T[0.. j] toe te voegen; bovendien is gemakkelijk in te zien dat er minstens j + 1 bewerkingen 

nodig zijn. Dus d−1, j moet j+ 1 zijn. Analoog moet di,−1 = i+1 zijn. 

De tabel voor S = presto en T = peseta, aangevuld met deze rij en kolom, is dan: 

−1 0 1 2 3 4 5 

p e s e t a 

−1 0 1 2 3 4 5 6 

0 p 1 0 1 2 3 4 5 

1 r 2 1 1 2 3 4 5 

2 e 3 2 1 2 2 3 4 

3 s 4 3 2 1 2 3 4 

4 t 5 4 3 2 2 2 3 

5 o 6 5 4 3 3 3 3 

Algoritme 2.1 geeft de pseudocode voor deze berekening. De tijdscomplexiteit van dit algoritme 

is O(mn). 

Merk op dat de tabel berekend in Algoritme 2.1 ons meer dan enkel de afstanden geeft. Terugkerend 

van dm−1,n−1 kan immers bepaald worden welke van de drie toegelaten bewerkingen 

aanleiding gegeven heeft tot de waarde van dm−1,n−1. 

Voorbeeld 2.1.4. Bijvoorbeeld, voor de bovenstaande tabel is d5,5 = 3 omdat d4,4 = 2 en S[5] = 

T[5], terwijl d5,4 = 3 en d4,5 = 3. Hieruit kunnen we besluiten dat de laatste bewerking in de 


2.2. Beste benaderende match 23 

goedkoopste omzetting de wijziging van S[5] = p in T[5] = a is. Vervolgens bekijken we hoe 

de waarde van d4,4 = 2 bepaald werd, nl. uit d3,3 = 2 (geen bewerking). De waarde d3,3 = 2 

komt van d3,2 = 1 met een tussenvoeging van e op positie 3. De waarde d3,2 = 2 keert terug 

tot d2,1 = 1 (geen bewerking), die op zijn beurt afkomstig is van d1,0 = 1 (geen bewerking). De 

waarde d1,0 = 1 is bepaald uit d0,0 = 0 (verwijder r op positie 1), die op zijn beurt teruggaat 

op d−1,−1 = 0 (geen bewerking). Dit levert ons de reeks bewerkingen die presto omzetten 

in peseta: verwijder r op positie 1 (dit levert pesto), voeg e tussen op positie 3 (dit levert 

peseto), wijzig o in a op positie 5 (dit levert peseta). 

2.2 Beste benaderende match 

Bij het zoeken van een patroon in een tekst zijn we dikwijls geïnteresseerd in het vinden van een 

benaderende match, eerder dan een exacte match. In een algemene formulering van het probleem 

is een patroon P en een tekst T gegeven en proberen we een gedeelte van de tekst te vinden dat 

zo sterk mogelijk gelijkt op P. De oplossing hangt dan af van de maat van gelijkenis die we 

gebruiken. Wanneer we de editeerafstand gebruiken, dan wordt het probleem het volgende: 

Gegeven een patroon P en een tekst T , zoek een deelwoord W = T[i.. j] zodanig dat 

de editeerafstand d(P,W) zo klein mogelijk is. 

Het woord W wordt beschouwd als een benaderende match en d(W,P) is een maat van hoe goed 

de match is. 

Bijvoorbeeld, de beste match voor het patroon retrieve in de tekst 

retreive, retreeve, retreev 

is het deelwoord retreeve startend op positie 10, omdat het afstand 1 heeft (nl. i vervangen 

door e). 

Een eenvoudige manier om de beste benaderende match te vinden bestaat erin om de editeerafstand 

te berekenen tussen het patroon P en alle mogelijke deelwoorden van T , en de kleinste 

afstand daarin te bepalen. Zij m = |P| en n = |T|. Er zijn n 2 deelwoorden van T en het vergelijken 

van elk daarvan met P kost O(mn), zodat de totale tijdscomplexiteit O(mn 3 ) wordt. 

Dit eenvoudige algoritme is echter in strijd met een van de basisregels van dynamisch programmeren, 

nl. dat informatie die reeds berekend werd niet opnieuw mag berekend worden. Immers, 

beschouw het berekenen van de editeerafstand op P en T . Het algoritme berekent waarden 

d(P[0..i],T[0.. j]), voor alle 0 ≤ i < m en 0 ≤ j < n. Het geeft dus de editeerafstanden van P tot 

alle prefixen van T . Dit komt reeds zeer dicht bij wat we nodig hebben, met dit verschil dat we 

ook de editeerafstanden tot suffixen van T[0.. j] nodig hebben, voor alle j. 

We definiëren 

adi, j = min{d(P[0..i],T[ℓ, j]) | 0 ≤ ℓ ≤ j+ 1}, 



m.a.w. adi, j is de kleinste editeerafstand tussen P[0,i] en een deelwoord van T dat eindigt in j 

(mogelijks de lege string, als ℓ = j + 1). De waarde die we zoeken, is dan het minimum 

van adm−1,0,adm−1,1,...,adm−1,n−1. De nieuwe tabel adi, j ziet er ingewikkelder uit dan di, j, 

maar kan berekend worden door gebruik te maken van dezelfde formule als voor de berekening 

van di, j: 

⎧ 

⎪⎨ 

0 als P[i] = T[ j] 

adi−1, j−1 + 

1 anders 

adi, j = min 

⎪⎩ 

adi, j−1 + 1 

adi−1, j + 1 

De juistheid van deze formule kan op dezelfde manier geargumenteerd worden als bij de formule 

voor di, j. Wanneer P[i] = T[ j], dan kunnen we de match gevonden door adi−1, j−1 uitbreiden. 

Wanneer P[i] = T[ j], dan zijn er drie mogelijkheden voor hoe de laatste letter van P[0..i] en 

T[ℓ.. j] matchen: vervangen van P[i] door T[ j], verwijderen van P[i], of toevoegen van T[ j] aan 

het einde van P. 

De berekening van de tabel adi, j verschilt van de berekening van di, j in de initialisatie. In de 

definitie van adi, j wordt als extreem geval toegelaten dat P[0..i] tot de lege string herleid wordt. 

M.a.w. ad−1, j = 0 voor alle j (omdat de lege string een deelstring is van om het even welke string 

op om het even welke positie j). 

Algoritme 2.2 geeft de pseudocode voor deze berekening. De complexiteit van dit algoritme 

is O(mn). 

Bepalen we bijvoorbeelde de beste benaderende match voor het patroon P = gogle in de tekst 

T = internet,google,search. We bekomen de volgende tabel: 

−1 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 

i n t e r n e t , g o o g l e , s e a r c h 

−1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

0 g 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 1 

1 o 2 2 2 2 2 2 2 2 2 2 1 0 1 1 1 2 2 2 2 2 2 2 2 

2 g 3 3 3 3 3 3 3 3 3 3 2 1 1 1 2 2 3 3 3 3 3 3 3 

3 l 4 4 4 4 4 4 4 4 4 4 3 2 2 2 1 2 3 4 4 4 4 4 4 

4 e 5 5 5 5 4 5 5 4 5 5 4 3 3 3 2 1 2 3 4 5 5 5 5 

De kleinste waarde in de laatste rij is 1, en dus hebben we een match voor gogle van die afstand. 

Door de 1 achterwaarts te volgen, vinden we dat de match op posities 9 t.e.m. 14 voorkomt. 

Noemen we een match W een k-benaderende match voor P als d(P,W) ≤ k. Dan kunnen we 

de vraag stellen of er, voor een gegeven patroon P en een gegeven tekst T , een k-benaderende 

match bestaat. Algoritme 2.2 lost dit probleem op in tijd O(mn). 


2.2. Beste benaderende match 25 

Algoritme 2.2 Bepalen van de beste benaderende match (in editeerafstand) tussen een patroon P 

en een tekst T 


Output: de kleinst mogelijke editeerafstand tussen P en een deelwoord van T 

1: {Initialiseren van kolom −1} 

2: for i from −1 to m − 1 do 

3: Stel ad[i,−1] ← i+1 

4: {Initialiseren van rij −1} 


6: Stel ad[−1, j] ← 0 

7: {Berekening van de eigenlijke tabel} 

8: for i from 0 to m − 1 do 


10: if P[i] = T[ j] then 

11: Stel x ← ad[i − 1, j − 1] 

12: else 

13: Stel x ← 1+ad[i − 1, j − 1] 

14: Stel ad[i, j] ← min(x,1+ad[i, j − 1],1+ad[i − 1, j]) 

15: {Bepalen van de kleinste editeerafstand} 

16: Stel a ← m 


18: if ad[m − 1, j] < a then 

19: Stel a ← ad[m − 1, j] 

20: return a

Algoritmen en Datastructuren III Partim: Algoritmen voor strings - caagt

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?