ALGORITMEN EN COMPLEXITEIT

Transcriptie

1 ALGORITMEN EN COMPLEXITEIT Syllabus Prof. dr. D. Janssens 1

2 Enkele klassiekers op dit gebied: [1 ] Aho, Hopcroft, Ullman, The Design and Analysis of Computer Algorithms, Addison-Wesley, [2 ] Garey, Johnson, Computers and Intractability, Freeman, [3 ] Hopcroft, Motwani, Ullman, Introduction to Automata Theory, Languages and Computation, Addison- Wesley, [4 ] R. Motwani, P. Raghavan, Randomized Algorithms, Cambridge University Press, Een recent overzicht: A Short History of Computational Complexity, op 2

3 1. Complexiteitsfuncties We nemen aan dat men met elk stel invoerwaarden van een algoritme een natuurlijk getal kan associeren, dat de grootte van de invoer voorstelt. Voor een sorteeralgoritme neemt men bv. het aantal te sorteren elementen. Voor een gegeven getal n kan men dan kijken naar T(n), de maximale tijd nodig voor het verwerken van een invoer van grootte n, en naar S(n), de maximale hoeveelheid geheugenruimte nodig voor het verwerken van een invoer van grootte n. Men associeert dus twee rekenkundige functies met het algoritme: T(n), de tijdscomplexiteit, en S(n), de plaatscomplexiteit. Meestal zijn we enkel geïnteresseerd in de orde van die functies. 3

4 Algoritme Tijdscompl. 1 sec 1 min 1 uur A 1 n A 2 n log(n) A 3 n A 4 n A 5 2 n De laatste drie kolommen geven telkens de maximale invoergrootte (als tijdseenheid is 1 milliseconde gebruikt). Stel dat A 1, A 2,..., A 5 respectievelijk precies 1000 n, 100 n log(n), 10 n 2, n 3 en 2 n stappen nodig hebben. Volgende tabel geeft dan de meest efficiënte algoritmen voor verschillende waarden van n: 2 n 9 A 5 10 n 58 A 3 59 n 1024 A 2 n 1025 A 1 We zullen verschillende algoritmen bekijken voor eenzelfde probleem, en daarvan de complexiteit vergelijken. Dit gebeurt door boven- en benedengrenzen te zoeken en te vergelijken. 4

5 We gebruiken rekenkundige functies (van IN naar IN) om over de complexiteit van algoritmen te redeneren. Om functies met elkaar te vergelijken gebruiken we de big oh (orde) notatie: O(f) = {g : IN IN er bestaan constanten c en n 0 met g(n) c f(n) voor elke n met n n 0 } Stelling. Als g O(f) en f O(g) dan O(f) = O(g) (dit bepaalt een equivalentierelatie). Als f 1, f 2 O(g) en c is een constante, dan geldt: f 1 + f 2 O(g), f 1 f 2 O(g 2 ), c f 1 O(g). Er is een polynomiaal verband tussen de functies f 1 en f 2 als er polynomen p 1 (x), p 2 (x) bestaan zodat f 1 (n) p 1 (f 2 (n)) en f 2 (n) p 2 (f 1 (n)). 5

6 We hebben de volgende rekenkundige eigenschappen nodig. Stelling. Stelling. n i=0 q i = qn+1 1 q 1 i=1... i 2 i = 2 Stelling. log a b = log a c log c b O(log a n) = O(log c n) a logcb = b log ca Stelling. O(log(n!)) = O(n log(n)) Bewijs: n! < n n, dus geldt log(n!) < n log(n). Anderzijds, n! > n (n 1)... ( n/2 ) > (n/2) n/2 en 6

7 bijgevolg log(n!) > (n/4)log(n) (voor n 4). Stelling. Bewijs: O( n i=1 log(i)) = O(n log(n)) 2 log(1)+log(2)+...+log(n) = 2 log(1) 2 log(2)... 2 log(n) Bijgevolg geldt n i=1 = n = 2 log(n!) log(i) = log(n!). De analyse van het aantal stappen dat een algoritme nodig heeft leidt vaak tot recurrentieformules. Hier volgen enkele eigenschappen over recurrentieformules en hun oplossingen. Stelling. Gegeven een recurrentieformule van volgende vorm: T(1) = c T(n) = p(t(n 1)), met p een polynoom. Dan heeft deze formule een unieke oplossing; m.a.w. er is een functie T die voldoet en als zowel T 1 als T 2 voldoen, 7

8 dan geldt T 1 (n) = T 2 (n) voor elke n. (Bewijs: inductie naar n.) Stelling. Als T(2) = 1 T(n) = 2 T(n/2) + 2, voor n = 2 k, waar k 2 Dan is T(n) = 3 n/2 2, voor n een macht van 2. (Bewijs: inductie naar n.) Stelling. Laat a, b, c niet-negatieve constanten zijn, en T(1) = b T(n) = a T(n/c) + b n, voor n = c k, waar k 2. Dan geldt T(n) O(n), als a < c T(n) O(n log c n), als a = c T(n) O(n log ca ), als a > c Bewijs(schets): toon eerst aan, per inductie, dat voor n een macht van c geldt: T(n) = b n 0 i log c n (a/c) i. 8

9 Als a < c, dan convergeert de reeks, dus T(n) = d n voor een constante d. Als a = c, dan T(n) = b n log c n, en als a > c dan is de som gelijk aan (q (log cn)+1 1)/(q 1), met q = a/c. Deze laatste functie is O(a log cn ) wat hetzelfde is als O(n log ca ). 9

10 2. Berekeningsmodellen 2.1. Random Access Machine (RAM, [1]) Een RAM bestaat uit: Een read-only invoerband, met leeskop. Elke cel van de band bevat een geheel getal, en er is maar een eindig aantal cellen in gebruik (de overige bevatten nul). Een write-only uitvoerband, met schrijfkop. Elke cel bevat een geheel getal, of is blanco. De uitvoerband is oneindig lang. Een programma. Een locatieteller (LC) die een natuurlijk getal kan bevatten. Een geheugen. Werking: De leeskop begint links en gaat bij elke READ èèn cel naar rechts. 10

11 In het begin zijn alle cellen van de uitvoerband blanco. De schrijfkop begint links en gaat bij elke WRITE èèn cel naar rechts. Het geheugen bestaat uit een aftelbaar aantal registers r 0, r 1,... die alle een geheel getal kunnen bevatten of blanco kunnen zijn. In het begin van een uitvoering bevatten alle registers het getal nul. Het programma is een rij van instructies, die een label (nummer) hebben. Het getal in de locatieteller LC geeft aan wat de eerstvolgende uit te voeren instructie is. Alle rekenoperaties gebeuren in het register r 0, dat dus een speciale rol speelt (accumulator). Operanden van de instructies zijn van de vorm i, =i (literal), of *i (indirect adres). De beschrijving van de instructies en hun effect gebeurt met behulp van de memory-map c en de value-functie v: c(i) staat voor de inhoud van register r i en v staat voor waarde van een operand: v(i) = c(i), v(= i) = i, v( i) = c(c(i)). 11

12 instructie en operand betekenis LOAD a c(0) v(a) STORE i c(i) c(0) STORE *i c(c(i)) c(0) ADD a c(0) c(0) + v(a) SUB a c(0) c(0) v(a) MULT a c(0) c(0) v(a) DIV a c(0) c(0)/v(a) READ i c(i) input READ *i c(c(i)) input WRITE a output v(a) JUMP b LC b JGTZ b LC b als c(0) > 0 JZERO b LC b als c(0) = 0 HALT stop de berekening Hierin staat a voor een operand, i voor een registernummer en b voor een label. 12

13 Elk programma definieert een (partiële) functie van de inhoud van de invoerband naar de inhoud van de uitvoerband. Een programma kan op volgende manieren gebruikt worden: om een functie f(x 1, x 2,..., x n ) = y te berekenen, om talen te accepteren (accepteren = 1 schrijven en stoppen), om te beslissen (altijd stoppen, en 0 of 1 schrijven). 13

14 begin read r1; if r1 0 then write 0 else begin r2 r1; r3 r1-1; while r3 > 0 do begin r2 r2 r1; r3 r3 1 end; write r2 end end 14

15 RAM Pseudocode READ 1 read r1 LOAD 1 JGTZ pos if r1 0 then write 0 WRITE =0 JUMP endif pos: LOAD 1 STORE 2 r2 r1 LOAD 1 SUB =1 r3 r1 1 STORE 3 while: LOAD 3 JGTZ continue while r3 > 0 do JUMP endwhile continue: LOAD 2 MULT 1 r2 r2 r1 STORE 2 LOAD 3 SUB =1 r3 r3 1 STORE 3 JUMP while endwhile: WRITE 2 write r2 endif: HALT 15

16 begin d 0; read x; while x 0 do begin if x 1 then d d 1 else d d+1; read x end; if d = 0 then write 1 end 16

17 RAM Pseudocode LOAD =0 STORE 2 d 0 READ 1 while: LOAD 1 JZERO endwhile while x 0 do LOAD 1 SUB =1 of x 1 JZERO one LOAD 2 SUB =1 then d d 1 STORE 2 JUMP endif one: LOAD 2 ADD =1 else d d + 1 STORE 2 endif: READ 1 read x JUMP while endwhile: LOAD 2 JZERO output if d = 0 then write 1 HALT output: WRITE =1 HALT 17

18 We kunnen voor elk programma vier functies bekijken: de worst-case-tijdscomplexiteit, de expected-case-tijdscomplexiteit, de worst-case-plaatscomplexiteit, de expected-case-plaatscomplexiteit. Uiteraard zijn dit telkens functies van IN naar IN. We concentreren ons voorlopig vooral op de tijdscomplexiteit. De bekomen resultaten zijn afhankelijk van de veronderstellingen die gemaakt worden over de tijd (of plaats) nodig voor de uitvoering van een instructie. We bekijken twee mogelijkheden: 1. Het Uniform Kost Criterium: alle instructies kosten èèn tijdseenheid en elk register vraagt èèn plaatseenheid. 2. Het Logaritmisch Kost Criterium: dat houdt rekening met de lengte van operanden. 18

19 Laat, voor een geheel getal n, l(n) gedefinieerd zijn door: l(n) = log(n) + 1 als n > 0 1 als n = 0 log( n) + 1 als n < 0 Dan neemt men voor de plaatscomplexiteit de som van de l(x i ), waar x i de grootste waarde is die tijdens de berekening voorkomt in register r i. (De som uiteraard over alle gebruikte registers). Voor de tijdscomplexiteit heeft men bv. LOAD =i l(i) LOAD i l(i) + l(c(i)) LOAD *i l(i) + l(c(i)) + l(c(c(i))) STORE i l(c(0)) + l(i) STORE *i l(c(0)) + l(i) + l(c(i)) DIV =i l(c(0)) + l(i) JUMP b 1 JZERO l(c(0)) Ook bij gebruik van het logaritmisch kost criterium blijven een aantal aspecten buiten beschouwing: we doen bv alsof de analyse van een instructie geen tijd neemt. 19

20 2.2. Random Access Stored Program Machine (RASP, [1]) Het programma staat in het geheugen. LC staat in het geheugen. De analyse van een instructie vraagt tijd. De RASP heeft dezelfde instructies als de RAM, behalve die waarin indirecte addressering voorkomt. Elke instructie staat in een paar van opeenvolgende geheugenregisters: in het eerste staat de (code voor de) operatie, in het tweede staat de operand. We nemen bv. aan dat de codering van de operaties de volgende is. LOAD =i 1 SUB =i 7 WRITE i 13 LOAD i 2 MULT i 8 WRITE =i 14 STORE i 3 MULT =i 9 JUMP i 15 ADD i 4 DIV i 10 JGTZ i 16 ADD =i 5 DIV =i 11 JZERO i 17 SUB i 6 READ i 12 HALT 18 De instructies worden sequentieel uitgevoerd, behalve bij jumps. Voor de tijds-kost van een instructie heeft men 20

21 nu bv, met het logaritmisch kost criterium: ADD i (in r j en r j+1 ) ADD =i (in r j en r j+1 ) l(j) + l(c(0)) + l(i) + l(c(i)) l(j) + l(c(0)) + l(i) De volgende twee resultaten drukken uit dat de tijdscomplexiteit niet echt verandert door de overgang van RAM naar RASP of omgekeerd. Stelling. Als de tijdscomplexiteit van een RAM programma T(n) is, dan bestaat er een constante k en een equivalent RASP programma met tijdscomplexiteit k T(n). Dit geldt zowel voor het uniform als voor het logaritmisch kost criterium. Bewijs: We beschrijven een RASP programma voor de simulatie van een gegeven maar verder willekeurig RAM programma. Register r 0 dient om te rekenen, en r 1 wordt gereserveerd om als dat nodig is een copie van r 0 bij te houden. Het RASP programma wordt in registers r 2,..., r p geplaatst; p zal enkel afhangen van het gegeven RAM programma. Als een instructie van het RAM programma refereert naar register r i, dan zal de overeenkomstige instructie van het RASP programma moeten refereren naar register r i+p. 21

22 De instructies zonder indirecte adressering kunnen verder gewoon overgenomen worden in het RASP programma. Instructies met indirecte adressering worden vervangen door een rij van 6 RASP instructies. Zo wordt SUB *i bv. vervangen door: register inhoud RASP instr verklaring STORE inhoud r 0 bewaren in r LOAD r i van RAM laden, 103 i+p i+p dus i+p ADD = adres verhogen 105 p p met p STORE adres in tweede deel van SUB-instr LOAD inhoud r 0 herstellen SUB eigenlijke simulatie, tweede deel ingevuld door STORE

23 Bij gebruik van het uniform kost criterium is uiteraard k = 6. Ook voor het logaritmisch kost criterium bestaat er een k (zie [1], p18). Stelling. Als de tijdscomplexiteit van een RASP programma T(n) is, dan bestaat er een constante k en een equivalent RAM programma met tijdscomplexiteit k T(n). Dit geldt zowel voor het uniform als voor het logaritmisch kost criterium. Bewijs: Er moet nu een RAM programma geconstrueerd worden dat een gegeven RASP programma simuleert. r 1 wordt gebruikt voor indirecte adressering, r 2 voor de locatieteller van de RASP, en r 3 voor de r 0 van de RASP. Initializeer r 2 met 4. Het RAM programma bestaat uit een loop die telkens een RASP operatie leest (LOAD *2), en op basis van de gelezen code naar èèn van 18 programmadelen springt, die elk èèn van de 18 mogelijke operaties simuleren. Zo wordt SUB i (van de RASP) bv. gesimuleerd door: 23

24 LOAD 2 laat r 2 naar het adresdeel van de ADD =1 te simuleren instructie verwijzen. STORE 2 LOAD *2 laad de oorspronkelijke i, ADD =3 en verhoog i met 3 STORE 1 r 1 bevat nu i+3 LOAD 3 laad de r 0 van de RASP SUB*1 de eigenlijke simulatie STORE 3 resultaat in r 3 LOAD 2 laat r 2 naar de volgende ADD =1 halve instructie verwijzen STORE 2 JUMP a ga terug naar de loop Het bestaan van de constante k wordt aangetoond op dezelfde manier als in vorige stelling. 24

25 2.3. Deterministische Multitape Turing Machine (DMTT, [1]) De meeste resultaten over complexiteit van problemen (in tegenstelling tot individuele algoritmen) worden bewezen voor een meer primitief model: de Turing Machine. Een geheugenplaats van een TM kan enkel èèn van een eindig aantal symbolen bevatten, en dus geen willekeurig groot getal. We bekijken Turing machines met k banden; deze banden zijn aan èèn kant oneindig (rechts) en ze zijn verdeeld in cellen waarin telkens plaats is voor èèn symbool. Op elke band wordt èèn cel gelezen en/of veranderd. Bij het begin van de berekening staan de lees-schrijfkoppen op de meest linkse cel van elke band. Er is een eindig aantal symbolen beschikbaar, en er zijn slechts eindig veel toestanden. Een DMTT wordt gespecifieerd als een 7-tupel waar (Q, T, I, δ, b, q 0, q f ) Q de verzameling van toestanden is, T de verzameling van symbolen is, 25

26 I de verzameling van inputsymbolen is, I T, b het blanco-symbool is, b T I, q 0 de begintoestand is, q 0 Q, q f de eindtoestand is, q f Q, en δ : (Q {q f }) T k Q (T {L, R, S}) k de transitiefunctie is. Verzameling van configuraties: Q (T T ) k. Op de verzameling van configuraties wordt een stap-relatie gedefinieerd. De transitieve en reflexieve sluiting daarvan wordt met genoteerd. 26

27 Laat M een DMTT zijn. De taal geaccepteerd door M is de verzameling L(M) = {w I er bestaan v 1,..., v k met (q 0, w,,..., ) (q f, v 1, v 2,..., v k )}. De functie berekend door M is de (partiële) functie F(M) : I I gedefiniëerd door: F(M)(w) = v 1, als (q 0, w,,..., ) (q f, v 1, v 2,..., v k ) ongedef., anders. Zoals voor de andere modellen hebben we: T(n) is het maximale aantal stappen nodig voor een invoer van lengte n, S(n) is het maximale aantal cellen op èèn van de banden gebruikt in de verwerking van een invoer van lengte n. Een Deterministische Turingmachine (DTM) is een DMTT met k = 1. 27

28 Stelling Elke taal die aanvaard wordt door een DMTT wordt ook aanvaard door een DTM. Bewijs: Gegeven een DMTT M met k banden. Een DTM M 1 die M simuleert kan als volgt geconstrueerd worden. Als alfabet nemen we T 1 = ({0, 1} T) k m.a.w. de DMT M 1 heeft een band met 2 k sporen. Elk paar sporen wordt gebruikt om een band van M voor te stellen: de eerste helft stelt de positie van de lees/schrijfkop voor (overal nullen behalve waar de kop staat) en de tweede helft stelt de inhoud voor. Voor k = 2 krijg je dus zoiets als: a c a a a c c c c c c c c c c c a a a a Een stap van M wordt gesimuleerd in M 1 door eerst de kop vanaf de positie van de meest linkse 1 naar de positie van de meest rechtse 1 te verplaatsen, en intussen de door M gelezen symbolen in het geheugen op te slaan, en vervolgens terug naar links te gaan terwijl alle nodige veranderingen worden aangebracht. 28

29 De volgende twee resulaten tonen aan dat er een polynomiaal verband bestaat tussen de tijdscomplexiteit op RAM en DTM, wanneer men tenminste het logaritmisch kost criterium gebruikt. Stelling Laat M een DMTT zijn met tijdscomplexiteit T(n). Er bestaat een RAM M die M simuleert met T (n) in O(T(n)), voor het uniform kost criterium, en T (n) in O(T(n) log(t(n))), voor het logaritmisch kost criterium. Bewijs: de RAM gebruikt c registers als werkgeheugen en verder een register voor elke cel van de band; dus register c+k i+j wordt gebruikt voor de i-de cel van band j. Voor het inlezen en simuleren van M zijn O(T(n)) stappen nodig (dwz, f(n) stappen met f(n) O(T(n))). Het grootste getal in een register is van de grootte O(T(n)), omdat de DMTT maar ten hoogste zo ver naar rechts kan gaan. Het resultaat volgt. 29

30 Stelling Laat M een RAM zijn met tijdscomplexiteit T(n). Er bestaat een DMTT M die M simuleert met T (n) in O(T 3 (n)), voor het logaritmisch kost criterium. Bewijs: We geven eerst een bewijs voor het geval waarin de RAM geen MULT en DIV instructies bevat, en T 2 (n). Er zijn 3 banden, die gebruikt worden als volgt. band 1: ##i 1 #c 1 ##i 2 #c 2 ##... ##i k #c k ##, waar de i j registernummers zijn en de c j hun inhoud (in binaire voorstelling) band 2: inhoud van r 0 band 3: werkgeheugen Instructies zoals bv ADD*20 of STORE 30 kunnen als volgt gesimuleerd worden. 30

31 ADD *20 zoek op band 1 ##10100, dus i j = 20 copieer c j naar band 3 zoek op band 1 de i j die gelijk is aan de inhoud van band 3 copieer c j naar band 3 tel de inhoud van band 3 op bij die van band 2 STORE 30 zoek op band 1 ##11110, dus i j = 30 copieer het stuk van band 1 vanaf de eerstvolgende ## naar band 3 copieer de inhoud van band 2 op band 1 copieer de inhoud van band 3 rechts daarvan De band kan nooit langer worden dan O(T(n)), dus het opzoeken duurt slechts O(T(n)). ADD en STORE zelf nemen ook ten hoogste O(T(n)). Er zijn O(T(n)) RAM instructies uit te voeren. Dat geeft dus in totaal O(T 2 (n)). 31

32 Voor het algemene geval, waar ook MULT en DIV mogen voorkomen, volstaat het DTM-subroutines te schrijven die MULT en DIV simuleren, en die zo zijn dat de logaritmische kost ervan niet groter is dan het kwadraat van de logaritmische kost van de gesimuleerde instructie. Het resultaat geldt niet als men het uniform kost criterium gebruikt: Stelling. Er bestaat een RAM R die niet gesimuleerd kan worden door een DTM M zodanig dat er een polynomiaal verband bestaat tussen de (uniforme kost) tijdscomplexiteit van R en die van M. Bewijs: Het is heel eenvoudig een RAM te schrijven die in O(n) stappen de functie f(n) = 2 (2n) berekent. In pseudocode: j 2 doe n keer j j j Voor de representatie van het getal 2 (2n) heeft de DTM O(2 n ) cellen nodig. 32

33 2.4. PASCAL Elk PASCAL programma kan gesimuleerd worden door een RAM en omgekeerd. Er is een polynomiaal verband tussen de tijdscomplexiteiten, net zoals tussen RAM/RASP met logaritmische kost en DTM. 33

34 3. Sorteringsalgoritmen Sorteringsalgoritmen komen veel voor en zijn vrij goed bestudeerd. In dit hoofdstuk bekijken we enkele resultaten i.v.m. de worst-case tijdscomplexiteit en de expected tijdscomplexiteit. Specificatie: gegeven een rij S = a 1, a 2,..., a n van elementen uit een totaal geordende verzameling (A, ), zoek een permutatie π van {1, 2,...,n} zo dat a π(1) a π(2)... a π(n). 34

35 Men kan verschillende soorten sorteringsalgoritmen onderscheiden: comparison-based: elementen kunnen enkel vergeleken worden met elkaar, verdere informatie over de structuur van de elementen wordt niet gebruikt. andere: de te sorteren elementen zijn getallen, woorden, enz, en hebben dus een niet triviale structuur die bij het sorteren gebruikt wordt. of ook: intern (in-place), extern. 35

36 3.1. Niet Comparison-Based Sorteren 1. Radix Sort Eerste versie: laat A = {1, 2,...,m}. Het algoritme gebruikt m queues Q[i], dus èèn per mogelijke waarde. Deze queues noemt men buckets. begin 1. Initializeer m lege queues Q[1], Q[2],...,Q[m]; 2. for i := 1 to n do plaats a i in queue Q[a i ] od; 3. concateneer de queues Q[1], Q[2],...,Q[m] end Voor de worst-case tijdscomplexiteit heeft men: 1. O(m) 2. O(n) 3. O(m) en dus voor het hele algoritme O(m + n). 36

37 Tweede versie: Laat A k de verzameling zijn van alle woorden van lengte k over een alfabet A met m letters. Neem aan dat ook een totale orde op A gegeven is: A = {a 1, a 2,..., a m } met a i a j als i j. Ook de lexicografische orde op A k wordt met genoteerd; dus voor s 1, s 2 A k geldt s 1 s 2 als ofwel 1. s 1 = a.s 1 en s 2 = a.s 2 voor a A en s 1 s 2, ofwel 2. s 1 = a.s 1 en s 2 = b.s 2 voora, b A met a b. 37

38 De input bestaat nu uit n woorden s 1, s 2,...,s n in A k. Met s ij wordt de j-de letter van s i genoteerd; dus s ij A. Naast de m buckets Q[l] wordt nog een queue Queue gebruikt. begin plaats s 1, s 2,..., s n in Queue for j := k downto 1 do begin for l := 1 to m do maak Q[l] leeg while Queue niet leeg do begin laat s i het eerste element van Queue zijn; verplaats s i van Queue naar Q[s ij ]; end for l := 1 to m do concateneer Q[l] achter Queue end end 38

39 Voorbeeld Laat A = {1, 2, 3}, input: 312, 321, 233, 132, 311, 211. input (out) Queue (in) Figuur 1: Radix Sort: tweede versie De worst-case tijdscomplexiteit is nu O((m + n) k). 39

40 Derde versie: uitbreiding tot A, dwz. de verzameling van alle woorden over het geordende alfabet A. De lexicografische orde op A is gedefiniëerd door: s 1 s 2 als ofwel 1. s 1 is het lege woord, ofwel 2. s 1 = a.s 1 en s 2 = a.s 2 voor a A en s 1 s 2, ofwel 3. s 1 = a.s 1 en s 2 = b.s 2 voor a, b A met a b. De input bestaat nu uit n woorden s 1, s 2,..., s n in A. Een mogelijke oplossing bestaat erin alle woorden rechts aan te vullen met een speciaal ( padding ) symbool ß, met ß a voor elke a A, en dan het vorige algoritme toe te passen. De gewone orde op natuurlijke getallen (binair of decimaal voorgesteld) is hiervan een variant: blanco is dan het padding symbool, maar de padding gebeurt links. Nadeel: dit is inefficiënt. 40

41 l i is de lengte van s i, l max is het maximum van de l i, en l tot = n i=1 l i, dus l tot is het totale aantal letters van de input. Het algoritme gebruikt l max lijsten Length[l] die de s i bevatten van lengte l, dus die met l i = l. Verder gebruikt het l max gesorteerde lijsten Nonempty[l] die, in volgorde en zonder duplicaten, de j bevatten zo dat de letter a j op positie l voorkomt; dus die waarvoor een i bestaat met s il = a j. 41

42 begin initializeer de lijsten Length[l] en Nonempty[l]; maak Queue leeg; for l := 1 to m do maak Q[l] leeg for j := l max downto 1 do begin concateneer Length[j] voor Queue; while Queue niet leeg do begin laat s i het eerste element van Queue zijn; verplaats s i van Queue naar Q[s ij ]; end for elke l in Nonempty[j] do begin concateneer Q[l] achter Queue maak Q[l] leeg end end end 42

43 Tijdscomplexiteit: De woorden s i kunnen voorgesteld worden in een array, waarin elke s i voorafgegaan wordt door zijn lengte. Het manipuleren van de s i kan dan gebeuren via pointers in die array. De hulpstructuren Length[l], Q[l] en Queue bevatten dus enkel pointers, en het verplaatsen van de s i kan in èèn stap. Voor het initializeren van de Nonempty[l], sorteer eerst lexicografisch de koppels (j, s ij ). Dit kan in O(m+l tot ) tijd. Ook het initializeren van de Length[l] kan in O(l tot ) tijd. Laat n j het aantal s i zijn die tenminste lengte j hebben, en laat m j de lengte zijn van Nonempty[j]. Dus zeker m j n j, en l max j=1 n j = l tot. Voor elke j zijn er O(m j + n j ) stappen nodig. Dat geeft een totaal van O( l max j=1 (n j +m j )) = O(l tot ) stappen voor de tweede for -lus. Rekening houdend met de eerste lus (initializatie van de buckets Q[l]), is de worst-case tijdscomplexiteit van het hele algoritme bijgevolg O(m+l tot ). 43

44 2. Toepassing: isomorfisme van bomen Een isomorfisme tussen bomen is een bijectie f tussen de knopen die de structuur bewaart: m.a.w. er is een tak (x, y) in de eerste boom d.e.s.d. als er een tak (f(x), f(y)) is in de tweede boom. We tonen aan: Stelling. Er bestaat een algoritme dat in O(n) tijd nagaat of twee bomen T 1 en T 2, elk met ten hoogste n knopen, isomorf zijn. Bewijs: Laat de knopen op niveau i van een boom de knopen zijn op afstand i van de wortel. Laat h de maximale hoogte zijn van T 1 en T 2. Het algoritme gaat als volgt. 44

45 begin for i := h downto 0 do begin 1. ken aan de bladeren op niveau i het lege tupel () toe; 2. ken aan elke inwendige knoop v op niveau i het geordende tupel toe bestaande uit de getallen toegekend aan de kinderen van v; 3. orden lexicografisch de tupels van niveau i. Dit levert rijen S 1 en S 2 op. 4. vergelijk S 1 en S 2. Als S 1 S 2 dan zijn de bomen niet isomorf (stop). 5. als S 1 = S 2, nummer dan de verschillende elementen van S 1 met 1, 2,... (daarbij komen i.h.a. herhalingen voor). 6. ken elke knoop van niveau i het overeenkomstige getal toe. end; T 1 en T 2 zijn isomorf; end 45

46 Voorbeeld 1 (1,2) 2 1 (1,2,2) (1,1,1) (1,1) (1,1) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) 1 (1,2) 1 2 (1,1,1) (1,2,2) ( ) ( ) ( ) (1,1) ( ) (1,1) ( ) ( ) ( ) ( ) Figuur 2: Twee isomorfe bomen 46

47 Tijdscomplexiteit: het doorlopen van een boom kan in O(n). In een doortocht kan men lijsten maken van de niveaus. Hou per niveau een lijst bij van de knopen op dat niveau, gesorteerd naar de toegekende getallen. Als n i het aantal knopen is op niveau i, dan kunnen 2, 3, 4 en 5 in tijd O(n i+1 ). De rest kan in tijd O(n i ). De som over alle niveaus geeft O(n). 47

48 3.2. Comparison-Based Sorteren We geven eerst een algemeen resultaat dat een benedengrens geeft voor de worst-case complexiteit van een willekeurig comparison-based sorteeralgoritme. Voor functies f, g: f Ω(g) d.e.s.d. als g O(f). Stelling. Elk comparison-based sorteeralgoritme heeft een worst-case tijdscomplexiteit in Ω(n log(n)). Bewijs: alle mogelijke uitvoeringen kunnen voorgesteld worden in een beslissingsboom. Elke uitvoering, voor een gegeven stel invoerwaarden, komt overeen met een rij van uitspraken van de vorm x i x j of not x i x j, waar de x i x j de uitgevoerde testen zijn. Al deze uitvoeringen vormen een binaire boom; de knopen hebben als label een test x i x j en de takken hebben als label true of false. 48

49 Elk stel invoerwaarden bepaalt een uitvoering, en dus een blad van de boom. Elke uitvoering berekent een permutatie, en er zijn n! permutaties, die allemaal kunnen voorkomen, dus de boom heeft tenminste n! bladeren. De hoogte van de boom is evenredig met het aantal stappen in de langste uitvoering. Voor een binaire boom met hoogte h en aantal bladeren m geldt m 2 h en dus h log(m). Voor m = n! dus log(n!), en O(log(n!) = O(n log(n)). 49

50 1. Mergesort Sorteer een rij elementen a 1, a 2,...,a n. Neem voorlopig aan dat n = 2 k voor zekere k. function sort(i, j); begin if i j then begin m := (i + j 1)/2; merge(sort(i, m), sort(m + 1, j)); end; end; Initiële aanroep: sort(1, n). m is altijd geheel (per inductie). 50

51 Tijdscomplexiteit: stel n = (j i+1), dus n is het aantal te sorteren elementen in een aanroep sort(i, j). merge gebruikt n 1 vergelijkingen. Dus geldt voor het aantal vergelijkingen T(n): T(n) = 1, als n = 1 = 2 T(n/2) + n 1, als n > 1. Bijgevolg T(n) O(n log(n)) (zie inleiding). De argumentatie kan aangepast worden voor alle stappen (niet enkel vergelijkingen) en voor willekeurige n. 51

52 2. Heapsort Een heap is een binaire boom, opgevuld niveau per niveau, van links naar rechts, waarvan elke knoop een element bevat, en zo dat, voor elk paar knopen v, w geldt: v parent van w element(v) element(w). Een heap met n elementen wordt vaak bijgehouden in een array van lengte n; de kinderen van plaats i staan dan op plaatsen 2i en 2i + 1. Gebruik van zo een heap in heapsort: Gegeven: n elementen a 1, a 2,..., a n in een array A[1..n]. Permuteer de elementen tot ze een heap vormen. Verwissel A[1] met A[n]. A[1] is het grootste element. Permuteer tot A[1],...,A[n 1] terug een heap vormen. enz. 52

53 procedure Maakheap(A); begin for i := n downto 1 do Heapify(A, i, n); end; procedure Heapify(A, i, j); begin if (a i is geen blad) and (a i < a 2i or a i < a 2i+1 ) then begin if a 2i < a 2i+1 then k := 2i + 1 else k := 2i; verwissel a i en a k ; Heapify(A, k, j); end; end; 53

54 Heapify(A, i, j) permuteert de elementen a i,..., a j tot ze weer een heap vormen, vertrekkend van een situatie waarbij enkel a i verkeerd staat. Lemma. Als a i+1, a i+2,..., a n wortels zijn van heaps, dan zullen na de oproep Heapify(A, i, n) de elementen a i, a i+1,...,a n wortels van heaps zijn. Bewijs: met neerwaartse inductie op i. i = n: Heapify(A, n, n) doet niets, a n is de wortel van een heap, ok. i < n en a i is een blad: Heapify(A, i, n) doet niets, ok. i < n en a i is geen blad: a i a 2i en a i a 2i+1 : Heapify(A, i, n) doet niets, ok. a 2i+1 a 2i en a i < a 2i : a i en a 2i worden verwisseld en Heapify(A, 2i, n) wordt aangeroepen; ok. a 2i < a 2i+1 en a i < a 2i+1 : a i en a 2i+1 worden verwisseld en Heapify(A, 2i + 1, n) wordt aangeroepen; ok. 54

55 Stelling. Maakheap(A) maakt een heap in O(n) tijd. Bewijs: het lemma impliceert dat Maakheap(A) een heap maakt. Laat T(h) de tijd zijn die nodig is voor Heapify(A, i, n) indien i op hoogte h in de heap zit: m.a.w. h takken boven het niveau van a n. Dan geldt T(h) = T(h 1) + c en T(0) = d, voor constanten c en d. Dus T(h) is O(h). In een volledige binaire boom met n knopen zijn er n/2 h+1 knopen op hoogte h, en dus zijn er ook in een heap met n knopen ten hoogste n/2 h knopen op hoogte h. Laat k de hoogte zijn van de heap, dan is de totale tijd dus aangezien h=1,..., O( k h=0 h n 2 h ) = O(n), h = 2 (cfr. introductie). 2h 55

56 Het sorteeralgoritme. begin Maakheap(A); for i := n downto 2 do begin verwissel a 1 en a i ; Heapify(A, 1, i 1); end; end Na afloop staan de a i in niet-dalende volgorde (bewijs per inductie). Stelling. Heapsort sorteert in O(n log(n)) tijd. Bewijs: Heapify(A, 1, i) vraagt O(log(i)) tijd, want de hoogte van een heap met i elementen is ten hoogste log(i). Voor de totale tijd heeft men dus O( n i=1 log(i)) = O(n log(n)). 56

57 Expected-time complexiteit van comparison-based sorteren Neem aan dat alle permutaties van de n invoerelementen even waarschijnlijk zijn. Stelling. Elk comparison-based sorteeralgoritme heeft expected-time complexiteit in Ω(n log(n)). Bewijs: de expected-time complexiteit van een sorteeralgoritme, voor een invoer van grootte n, is tenminste b B p b l b, waar B de verzameling van bladeren van de beslissingsboom is, p b de waarschijnlijkheid van blad b, en l b de lengte is van het pad van de root naar het blad b. Als alle bladeren even waarschijnlijk zijn is p b = p voor elk blad b, en wordt dat p b B Laat, voor een boom T en een natuurlijk getal m, D(T) en D(m) bepaald zijn door: l b. D(T) is de som b B l b voor de boom T, D(m) is de minimale waarde van D(T) voor bomen T met tenminste m bladeren. 57

58 We tonen (per inductie) aan dat D(m) m log(m). m = 1: ok. stel D(k) k log(k) voor elke k met k < m. Laat T een boom zijn met tenminste m bladeren. Laat T l en T r respectievelijk de linker- en de rechterdeelboom van T zijn. Stel dat i het aantal bladeren is van T l. Dan geldt D(T) = i + D(T l ) + (m i) + D(T r ). Bijgevolg geldt, per inductie, D(m) = min 1 i m (m + D(i) + D(m i)) m + min 1 i m (i log(i) + (m i) log(m i)). De functie (i log(i) + (m i) log(m i)) bereikt een minimum voor i = m/2, en dus D(m) m + m log(m/2) = m log(m). Voor de beslissingsboom van een sorteeralgoritme is m = n! en p = 1 n! en dus is de expected-time complexiteit voor een invoer van grootte n tenminste ( 1 ) n! log(n!) = log(n!). n! Het resultaat volgt nu uit O(log(n!)) = O(n log(n)). 58

59 3. Quicksort Het algoritme sorteert een rij S van elementen a 1, a 2,..., a n. function Quicksort(S); begin if S heeft maar één element then return(s) else begin Kies a random uit S; S 1 := de rij van elementen < a uit S; S 2 := de rij van elementen = a uit S; S 3 := de rij van elementen > a uit S; return(append(quicksort(s 1 ), S 2,Quicksort(S 3 )); end; end Voor dit algoritme is de orde van de expected-time complexiteit optimaal. 59

60 Stelling. Quicksort(S) ordent S in O(n log(n)) expected tijd. Bewijs: Neem aan dat alle elementen van S verschillend zijn. Voor n = 0 en n = 1 is de verwachte tijd een constante b; dus T(0) = T(1) = b. Voor n > 1 geldt dat er een constante c bestaat met: T(n) c n + ( 1 n ) n (T(i 1) + T(n i)) i=1 = c n + ( 2 n ) n 1 (T(i)). i=0 We tonen aan, per inductie, dat voor n > 1, Voor n = 2 geldt: T(n) 2(b + c) n log e (n). T(2) = 2(b + c) 2 (b + c) 2 log e (2). Voor n > 2: T(n) c n + ( 2 n ) n 1 (T(i)) i=0 c n + ( 4b n ) + (2 n ) n 1 i=2 c n + ( 4b n ) + (4(b+c) n ) n 1 2(b + c) i log e i i=2 i log e i c n + ( 4b n ) + (4(b+c) n ) n x log 2 ex dx 60

61 c n + ( 4b n ) + (4(b+c) n ) ( (n2 log e n) 2 n2 4 ) c n + ( 4b n ) + 2(b + c) n log en (b + c) n 2(b + c) n log e n Waar (2) volgt per inductie, (4) en (5) uit de elementaire analyse, en (7) uit 4 n n voor n > 2. De worst-case tijdscomplexiteit is O(n 2 ). 61

62 4. Het k-de element selecteren Gegeven is een rij S van n elementen a 1, a 2,...,a n uit een totaal geordende verzameling A, en een k met 1 k n. Gevraagd wordt het k-de element te selecteren, m.a.w. een element a zo dat er k 1 elementen a zijn. Een simplistische oplossing bestaat erin eerst S te sorteren, en dan het k-de element (in volgorde) van de gesorteerde rij te selecteren. We tonen aan dat er betere algoritmen bestaan, met O(n) worst-case tijdscomplexiteit. Laat S de lengte van de rij S zijn. 62

63 function Select(k, S); begin if S < 50 then begin sorteer S; return k-de element; end; else begin verdeel S in deelrijen van elk 5 elementen; sorteer elke deelrij; M := de rij gevormd door 3 de elementen van elke deelrij; m :=Select( M /2, M); S 1 := de rij van elementen < m in S; S 2 := de rij van elementen = m in S; S 3 := de rij van elementen > m in S; if S 1 k then return Select(k, S 1 ); else if ( S 1 + S 2 k) then return m; else return Select((k S 1 S 2 ), S 3 ); end 63

64 Stelling. Dit algoritme heeft worst-case tijdscomplexiteit in O(n). Bewijs: Het aantal elementen van M die m zijn is tenminste n/10. Voor elk van die elementen zijn er nog twee andere (per deelrij van 5) die m zijn. Dus het totaal aantal elementen m in S is tenminste 3 n/10. Voor n > 50 geldt dus S 1 n 3 n/10 < 3n/4. Bijgevolg ook S 1 3n/4. Men kan een analoge redenering maken voor S 3. De recursieve aanroepen op het einde van het algoritme vragen dus elk ten hoogste T( 3n/4 ) tijd. Er bestaat dus een constante zo dat T(n) c n, voor n < 50, en T(n) T( n/5 ) + T( 3n/4 ) + c n, voor n 50. Men kan eenvoudig per inductie bewijzen dat, voor elke n, T(n) 20c n. 64

65 Stelling. Elk comparison-based algoritme voor het selecteren van het k-de element heeft expected-time complexiteit Ω(n). Eerst wordt een hulpresultaat bewezen. Laat T de beslissingsboom zijn van een algoritme dat het k-de element selecteert uit elementen a 1,...,a n. Laat p een pad in T zijn van de wortel tot een blad. Definieer de relatie R p op de {a 1,...,a n } door: a i R p a j als er een knoop op p is die overeenkomt met een test waarin a i en a j vergeleken worden en die als resultaat geeft dat a i < a j of a i a j. Laat R + p de transitieve sluiting zijn van R p. Lemma. Als het blad van p overeenkomt met de beslissing dat a m het k-de element is, dan geldt voor alle i met i m dat a i R + p a m of a m R + p a i. Bewijs: Stel dat er een element a i is met niet a i R + p a m en niet a m R + p a i. Dan kan men voor de a 1,..., a n twee concrete stellen waarden kiezen zó dat in het ene geval de waarde van a i net vóór die van a m ligt, in het andere geval net na die van a m, en dat alleen de waarde van a i in de twee gevallen verschillend is. Dit levert duidelijk een contradictie op: a m kan niet in beide gevallen het k-de element zijn. 65

66 Bewijs van de stelling: toon aan dat elk blad van de beslissingsboom T tenminste op afstand n 1 van de wortel ligt. Beschouw weer een blad en een pad p zoals voor het lemma. p bepaalt de relaties R p en R + p. Laat, voor elke i m, de hoofdknoop van i de eerste knoop zijn op p waar één van volgende dingen gebeurt: a i wordt vergeleken met a m, a i wordt vergeleken met a j, a i R p a j en er geldt a j R + p a m, a i wordt vergeleken met a j, a j R p a i en er geldt a m R + p a j. Uit het lemma volgt dat elke i m een hoofdknoop heeft. Een knoop kan geen hoofdknoop zijn van twee verschillende i, en dus volgt het resultaat. De benedengrens voor de expected-time complexiteit wordt al bereikt (op een constante na) voor het volgende, eenvoudige algoritme. 66

67 function Select(k, S); begin if S = 1 then return a 1 else begin kies m random in S; S 1 := de rij van elementen < m in S; S 2 := de rij van elementen = m in S; S 3 := de rij van elementen > m in S; if S 1 k then return Select(k, S 1 ); else if ( S 1 + S 2 k) then return m; else return Select((k S 1 S 2 ), S 3 ); end Stelling. De expected tijd van dit algoritme is in O(n). Bewijs: bekijk eerst de tijd nodig voor de recursieve oproepen. Als m het i-de element in volgorde van grootte is, dan vraagt de recursieve oproep T(n i) indien i < k en T(i 1) indien i k + 1. Dus gemiddeld wordt dat 1 n k 1 T(n i) + i=1 n i=k+1 T(i 1) 67

68 en, na wat herschikken, 1 n Bijgevolg geldt T(n) c n+max k n 1 i=n k+1 1 n T(i) + n 1 n 1 i=n k+1 i=k T(i). T(i) + n 1 i=k T(i). Men bewijst eenvoudig per inductie dat, als c zo gekozen is dat T(1) c, dan T(n) 4c n. 68

69 4. Grafen en Diskrete Structuren We beschouwen eerst het all pairs shortest path probleem. Door de labels van de takken van een graaf te nemen in een abstracte algebraische structuur, kunnen we een algemeen algoritme schrijven in termen van de operaties van die structuur. Door verschillende concrete modellen van de structuur te nemen bekomen we varianten van het algemene algoritme. De algebraische structuur die we nodig hebben is de volgende. Definitie. Een gesloten semiring is een structuur (S, +,,0,1) zodat (S, +) en (S, ) zijn monoiden (inwendig, associatief, neutraal element), en 0 en 1 zijn de neutrale elementen van (S, +) en (S, ), respectievelijk. + is commutatief en idempotent (a + b = b + a en a + a = a). 0 a = 0 = a 0. is distributief t.o.v. +. Aftelbare sommen i a i bestaan en zijn uniek. 69

70 De distributiviteit kan uitgebreid worden tot aftelbare sommen, m.a.w. ( i a i ) ( j b j ) = i,j a i b j. In een gesloten semiring wordt a gedefinieerd door: a = 1 + a + a a + a a a + Enkele voorbeelden: S 1 = ({0, 1}, +,, 0, 1), met + en de booleaanse operaties In dit geval is a = 1 voor elke a. S 2 = (R, min, +,, 0), waar R de sluiting van de niet-negatieve reële getallen is, en min en + dus de rol spelen van de + en, respectievelijk, uit de definitie. Hier geldt a = 0 voor elke a. S 3 = (F Σ,,,, {ɛ}), waar F Σ de verzameling van alle talen over Σ is, de concatenatie van talen en ɛ het lege woord. 70

71 Laat G = (V, E) een gerichte graaf zijn. Elke tak heeft als label een element van een gesloten semiring (S, +,,0,1). We kennen labels toe aan paden: een pad met lengte 0 krijgt label 1, en voor de andere paden neemt men het product van de labels van de takken. Stel, voor v, w V, c(v, w) gelijk aan de som van de labels van de paden van v naar w. Een algoritme om de c(v, w) te berekenen, voor een willekeurige S, is het volgende. 71

72 Gegeven: een graaf G = (V, E), met V = {v 1,... v n }, en een labeling functie l : V V (S, +,,0,1) met l(v i, v j ) = 0 als (v i, v j ) / E. Gevraagd: c(v i, v j ), voor elke i en j. begin for i := 1 to n do Cii 0 = 1 + l(v i, v i ); for i := 1 to n do for j := 1 to n do if i j then Cij 0 = l(v i, v j ); for k := 1 to n do for i := 1 to n do for j := 1 to n do C k ij := C k 1 ij + C k 1 ik for i := 1 to n do for j := 1 to n do c(v i, v j ) := C n ij end (C k 1 kk ) C k 1 kj ; 72

73 Stelling. Dit algoritme is correct en heeft worst-case complexiteit O(n 3 ), in de veronderstelling dat de operaties +, en maar een constante tijd in beslag nemen. Bewijs: de correctheid volgt uit het feit dat C k ij de som is van de labels van alle paden van v i naar v j met de eigenschap dat alle tussenliggende knopen behoren tot {v 1,..., v k }. Dat de tijdscomplexiteit in O(n 3 ) is, is evident. Speciale gevallen. Berekenen of er al dan niet een pad bestaat van v naar w, voor elk paar knopen v, w: neem de semiring S 1 en laat l(v, w) = 1 als (v, w) E en l(v, w) = 0 anders. Er komt dan op lijn 9 van het algoritme: C k ij := Ck 1 ij a {0, 1}. + C k 1 ik C k 1 kj, want a = 1 voor elke Berekenen van het kortste pad van v naar w, voor elk paar knopen v, w: neem de semiring S 2 en laat l(v, w) de lengte zijn van de tak (v, w). Op lijn 9 komt er dan: Cij k := min(cij k 1, Cik k 1 +Ckj k 1 ), want a = 0 voor elke a (0 speelt de rol van 1 in de definitie van gesloten semiring). 73

74 Een graaf G = (V, E) met n knopen en labeling l zoals in het voorgaande kan voorgesteld worden door een n n matrix A G met elementen l(v i, v j ) (adjacency matrix). Er is een nauw verband tussen het berekenen van de c(v i, v j ) en de vermenigvuldiging van matrices. Meer bepaald geldt het volgende. Als (S, +,,0,1) een gesloten semiring is, dan is de verzameling van n n matrices over S dat ook (+ is de componentsgewijze som, en is het matrixproduct). Het (i, j)-de element van A G A G A G (k keer) is de som van de labels van de paden van lengte k van v i naar v j. Bijgevolg is het (i, j)-de element van (A G ) gelijk aan c(v i, v j ). Het berekenen van het product van twee n n matrices over S en het berekenen van van een n n matrix over S zijn taken die computationeel equivalent zijn: op basis van een algoritme voor de ene taak kan men een algoritme construeren voor de andere, en zo dat de worst-case complexiteit slechts met een constante factor toeneemt. 74

75 Wanneer men een ring neemt in de plaats van een gesloten semiring (+ heeft inverse elementen), dan kan het matrixproduct in O(n (log7) ), wat beter is dan O(n 3 ). 75

76 Het single source shortest path probleem kan in minder tijd opgelost worden. Gegeven is een gerichte graaf G = (V, E), een knoop v 0 V, en een labeling functie l : V V R zodat l(v, v) = 0, voor elke v V, l(v, w) =, voor elke v, w V met v w en (v, w) / E, en l(v, w) 0 als v w. We gebruiken dus semiring S 2. Gevraagd is om c(v 0, v) te berekenen voor elke v, m.a.w. de kost van het goedkoopste pad van v 0 naar v. 76

77 Algoritme van Dijkstra: begin S := {v 0 }; D[v 0 ] := 0; for elke v V \ {v 0 } do D[v] := l(v 0, v); while S V do begin kies w V \ S met D[w] minimaal; S := S {w}; for elke v V \ S do D[v] := min(d[v], D[w] + l(w, v)); end; end 77

78 Stelling. Het algoritme is correct en heeft worst-case tijdscomplexiteit in O(n 2 ). Bewijs: het is evident dat de tijdscomplexiteit O(n 2 ) is. De correctheid volgt uit het feit dat na lijn 9 de volgende invariant geldt: Voor elke v S is D[v] de kost van het goedkoopste pad van v 0 tot v, en voor elke v V \ S is D[v] de kost van het goedkoopste pad van v 0 tot v dat, met uitzondering van v zelf, in S ligt. Dit wordt bewezen per inductie naar het aantal elementen van S. S = {v 0 }: ok. Stel dat w is toegevoegd, dus S = S {w}. v S : ok. v V \ S, v w: de paden die, op v na, in S liggen, maar niet in S, zijn paden die eindigen met (w, v), en die worden in lijn 9 correct in rekening gebracht. 78

79 v = w: stel dat er een goedkoper pad p zou zijn van v 0 naar w, dus met kost kleiner dan D[w]. Dan bevat p een knoop w buiten S, per inductie. Stel dat u de eerste dergelijke knoop op p is. Dan geldt per inductie dat D[u] < kost van p < D[w], maar dat is in strijd met de manier waarop w gekozen is. 79

80 5. Woorden en Reguliere Uitdrukkingen Woorden (rijen symbolen) zijn veruit de meest voorkomende discrete structuur. Sets van woorden (talen) kunnen eenvoudig gespecifieerd worden met reguliere uitdrukkingen; deze komen overeen met eindige automaten. We bekijken een algoritme voor het opzoeken van deelwoorden dat gebaseerd is op deze technieken. De reguliere uitdrukkingen over een alfabet Σ zijn gedefinieerd als volgt. is een r.u, en stelt de lege taal voor. ɛ is een r.u, en stelt de taal {ɛ} voor, waar ɛ het lege woord is. Voor elke a Σ is a een r.u, en stelt de taal {a} voor. Als u en w r.u. zijn die respectievelijk de talen U en W voorstellen, dan zijn (u + w), (u w) en (u ) r.u, die respectievelijk de talen U W, U W en U voorstellen. We spreken af dat de hoogste prioriteit heeft, dan en dan +, zodat we een deel van de haakjes kunnen weglaten 80

81 zonder dubbelzinnigheid in te voeren. Verder laten we soms gewoon weg, schrijven we w n voor w w w (n keer w), en voor een eindige verzameling A = {a 1,... a n } gebruiken we soms A voor a a n. Een niet-deterministische eindige automaat (NDFA) is een 5-tupel (Q, Σ, δ, q 0, F), met Q een eindige verzameling van toestanden, Σ een eindig alfabet, δ : Q (Σ {ɛ}) 2 Q de transitiefunctie, q 0 Q de begintoestand en F Q de verzameling van eindtoestanden. Stelling. Voor elke reguliere uitdrukking u kan er in O( u ) tijd een NDFA geconstrueerd worden die de taal voorgesteld door u aanvaardt. De NDFA heeft ten hoogste 2 u toestanden en vanuit elke toestand zijn er ten hoogste 2 verschillende stappen mogelijk (m.a.w, voor elke q is de som van de aantallen elementen in de δ(q, x) ten hoogste 2, waar de som genomen wordt over alle x Σ {ɛ}). 81

82 Stel dat men een algoritme wenst om te beslissen of een gegeven woord x = a 1 a 2... a n in Σ behoort tot de taal van een gegeven r.u. w. Een eerste oplossing bestaat erin de NDFA om te vormen tot een DFA en dan te testen of die x aanvaardt. Het nadeel daarven is dat de algemene constructie van een DFA voor een NDFA gebaseerd is op de vervanging van de toestandsverzameling Q door 2 Q, met als gevolg dat de constructie exponentieel afhangt van u. Daarom is het volgende algoritme beter (zie ook compilers ). 82

83 begin construeer de NDFA van w; for i := 1 to n do begin if i = 0 then Q i := {q 0 } else Q i := q Qi 1 δ(q, a i ); for elke q Q do klaar[q] := (q Q i ); Queue := Q i ; while Queue niet leeg do begin haal het eerste element t uit Queue; for elke u δ(t, ɛ) do if not klaar[u] then begin klaar[u] := true; voeg u toe aan Queue en Q i ; end; end; end; return F Q n ; end; 83

84 Stelling. Als m de lengte is van de reguliere uitdrukking w, dan heeft dit algoritme O(m n) tijd nodig. Bewijs: lijn 2 kan in O(m). Het deel binnen de for-lus (berekenen van de ɛ-sluiting) kan ook in O(m), want elke q komt ten hoogste één keer in Queue en op lijn 11 zijn er ten hoogste 2 u s. Beschouw nu een nog meer voorkomend probleem: het opzoeken van een woord y = b 1... b l in een ander woord x = a 1...a n. Gewoonlijk is n veel groter dan l. We kunnen het voorgaande resultaat toepassen: y komt voor in x d.e.s.d. als x behoort tot de taal van de r.u. Σ y Σ. Dat levert dus een tijdscomplexiteit in O(l n) op. We geven een beter algoritme dat in O(l + n) werkt. 84

85 Definitie. De falingsfunctie van een woord b 1... b l is de functie f : {1,...,l} {0,..., l 1} zodat, voor elke i met 1 i l, f(i) de grootste index is waarvoor b 1... b f(i) een echte suffix is van b 1... b i. Voorbeeld: voor het woord aabbaaba is f gegeven door: i f(i) Het algoritme is een deterministische eindige automaat M y met l + 1 toestanden, die x als invoer krijgt. Er zijn zowel gewone als ɛ-stappen, maar we spreken af dat er maar een ɛ-stap genomen wordt als er geen andere stap mogelijk is. De automaat is dus wel degelijk deterministisch. Het algoritme zal het de eerste occurrence van y in x vinden, als die bestaat l 1 l b 1 b 2 b 3 b l notb 1 Figuur 3: basisstructuur van M y 85

86 ɛ ɛ ɛ a a b b a b ɛ a ɛ 6 ɛ b 7 Figuur 4: M y voor y = aabbaab Als het algoritme in toestand i is op het ogenblik dat de j- de letter van x gelezen wordt, dan betekent dat: b 1...b i is de langste prefix van y die suffix is van a 1... a j. Als de volgende gelezen letter, a j+1, gelijk is aan b i+1, dan zal M y in de volgende stap naar toestand i + 1 gaan, maar als a j+1 b i+1, dan volgt er een ɛ-stap. Deze stap brengt M y naar de toestand q die overeenkomt met de op één na langste prefix van y die suffix is van a 1... a j. Dat is de langste prefix van y die echte suffix is van b 1...b i, en dus is q de toestand f(i). 86

87 De automaat M y kan ten hoogste n gewone stappen nemen. Voor wat de ɛ-stappen betreft: M y vertrekt in toestand 0, en elke ɛ-stap gaat van een toestand met hogere index naar een toestand met lagere index, want f(i) < i. De index kan echter maar n keer verhogen, want dat verhogen gebeurt enkel in de gewone stappen. Dus zijn er ook ten hoogste n ɛ-stappen. Besluit: M y doet ten hoogste 2n stappen. 87

88 Om het algoritme compleet te maken hebben we uiteraard ook een algoritme nodig om de falingsfunctie f te berekenen. begin f(1) := 0; for j := 2 to l do begin i := f(j 1); while (b j b i+1 ) and (i > 0) do i := f(i); if (b j b i+1 ) and (i = 0) then f(j) := 0 else f(j) := i + 1 end end In de toekenningen i := f(i) op lijn 6 wordt i verlaagd. De enige manier waarop i verhoogd wordt is de combinatie f(j) := i + 1 (lijn 8) j := j + 1 (lijn 3, for-lus) i := f(j 1) (lijn 5). 88

89 i is dan verhoogd met 1. Aangezien men begint met i = 0, wordt de body van de while-lus, i := f(i), ten hoogste l keer uitgevoerd. In combinatie met de eerdere beschouwingen over M y hebben we volgend resultaat. Stelling. Het algoritme bepaalt in O(l+n) tijd de eerste occurrence van y in x. 89

90 6. Intractability 6.1. P-TIME en NP-TIME In dit hoofdstuk bekijken we de complexiteit van problemen, en dus niet van individuele algoritmen. Meer bepaald bestuderen we klassen van problemen die in polynomiale tijd (deterministisch of niet-deterministisch) kunnen opgelost worden: P-TIME en NP-TIME. We gebruiken Turingmachines als berekeningsmodel; daarom moeten de problemen gecodeerd worden in woorden. Coderingen voor de structuren die we nodig hebben (grafen, sets, lijsten, enz.) zijn min of meer voor de hand liggend, en we nemen aan dat ze in polynomiale tijd in elkaar omgezet kunnen worden. Dat heeft voor gevolg dat we de coderingen buiten beschouwing kunnen laten. We bekijken beslissingsproblemen die voorgesteld worden d.m.v. talen. Een beslissingsprobleem is een functie P : I P {true, false}. De elementen van I P noemt men de instanties van P; 90

91 een instantie is dus een concrete mogelijke invoer voor P. Door de codering kunnen we I P zien als een verzameling van woorden; de taal die met P overeenkomt is dan de verzameling van alle woorden w waarvoor P(w) = true. Een groot aantal problemen kan op deze manier bestudeerd worden, zelfs als ze op het eerste gezicht niet van de juiste vorm zijn: bv. het optimalizatieprobleem bereken, in een gerichte graaf met een kost voor de pijlen, de kost van de goedkoopste cycle die alle knopen juist éénmaal bevat is nauw verbonden met het beslissingsprobleem (Traveling Salesman Problem, TS) is er, in een gerichte graaf met een kost voor de pijlen, een cycle die alle knopen juist éénmaal bevat en een kost heeft kleiner dan een gegeven getal k? 91