INF 4130 / / Dagens foiler hovedsakelig laget av Petter Kristiansen Foreleser Stein Krogdahl Obliger:

Transkript

1 INF 4130 / / Dagens foiler hovedsakelig laget av Petter Kristiansen Foreleser Stein Krogdahl Obliger: Tre stykker, som må godkjennes. Frister: 21. sept, 26. okt, 16. nov Andre, «nærliggende» kurs: INF-MAT 3370 Lineær optimering INF-MAT 5360 Matematisk optimering INF 1080 Logiske metoder for informatikk (INF 1800) MAT-INF 3600 Mathematical Logic MAT 4630 Beregnbarhets-teori

2 Algoritmer, effektivitet, kompleksitet Litt repetisjon Problem-klasser Elementene (punktene i planet) er her «problemer», og hver bue angir en problem-klasse definert ut fra hva slags algoritmer som kan løse problemene under buen. Problem-klassen P består f.eks. av de problemer som kan løses med algoritmer som går i «polynomisk tid» (i worst case) Merk: Hvert. problem består igjen av et antall «instanser», og for at det skal være et interessant problem må det ha uendelig mange instanser. Uløsbare unsolvable Umedgjørlige intractable (NP-komplette) Lette (P) Og: Vi er i dag i P

3 Problem: Søk etter gitt substreng i «lang» streng Er blitt mer aktuelt i det siste, bl.a. på grunn av: Søk i DNA-strenger etter et gitt mønster (eller et «liknende» mønster) Google og liknende søker etter gitte strenger på alle nettsider Det å søke etter et liknende mønster er veldig aktuelt i genetikk De forskjellige gen-sekvensene forandrer seg litt over tid pga. mutasjoner Slike søk er behandlet i kap Vi tar det i forbindelse med dynamisk programmering (kap. 9, neste uke) Vi håper å få besøk av gruppa for Bio-informatikk som snakker om deres bruk av slike algoritmer.

4 Problem: Søk etter gitt substreng i «lang» streng Et alfabet er en endelig mengde symboler A = {a 1, a 2,, a k }. En streng S = S[0:n-1] av lengde n er en sekvens av symboler fra A. Vi kan se på strengen S både som en array S[0:n -1] og som en sekvens av symboler S = < s 0 s 1 s n-1 > Søkeproblemet: Gitt to strenger T (= Tekst) og P (=Pattern/mønster), der P ikke er lenger enn T (og gjerne er mye kortere) Avgjør om strengen P finnes som (sammenhengende) substreng i T, og i så fall hvor n -1 T [0:n -1] (Tekst) P [0:m -1] (Pattern)

5 Varianter av søking i strenger Naiv algoritme, ingen prebehandling av T eller P Anta lengden av T og P er hhv. n og m Gir allerede en polynomisk algoritme, med «worst case» tid O(n*m), som altså også er O(n 2 ). Prebehandling av P (mønsteret) for hver ny P Prefiks-søking Knuth-Morris-Pratt-algoritmen Suffiks-søking Boyer-Moore-algoritmen Hash-basert Karp-Rabin-algoritmen Om man skal søke i den samme teksten mange ganger: Prebehandling (indeksering) av teksten. Teksten kan da f.eks. gjøres om til: Trie-trær Suffiks-trær

6 Naiv algoritme Søker forover Vindu n -1 T [0:n -1] P [0:m -1]

7 Naiv algoritme n -1 T [0:n -1] P [0:m -1]

8 Naiv algoritme n -1 T [0:n -1] P [0:m -1]

9 Naiv algoritme n-m n -1 T [0:n -1] P [0:m -1]

10 Naiv algoritme n-m n -1 T [0:n -1] P [0:m -1] function NaiveStringMatcher (P [0:m -1], T [0:n -1]) for s 0 to n - m do if T [s :s + m -1] = P then return(s) endif endfor return(-1) end NaiveStringMatcher

11 Naiv algoritme n-m n -1 T [0:n -1] P [0:m -1] function NaiveStringMatcher (P [0:m -1], T [0:n -1]) for s 0 to n - m do if T [s :s + m -1] = P then}for-løkka eksekveres n m + 1 ganger. return(s) Hver sjekk inntil m symbolsammenlikninger. endif O(nm) kjøretid (worst case inntreffer om P ikke endfor finnes, eller P ligger helt på slutten i T) return(-1) end NaiveStringMatcher

12 Knuth-Morris-Pratt-algoritmen Det er rom for forbedringer av den naive algoritmen Den naive algoritmen flytter vinduet/patternet bare ett hakk i hvert steg Kan vi kanskje flytte mer enn bare ett hakk, ut fra hva vi vet pga. testene i forrige steg Vi ser på følgende eksempel:

13 Knuth-Morris-Pratt-algoritmen Søker forover

14 KMP-algoritmen

15 KMP-algoritmen Flytter ett hakk. Ikke match

16 KMP-algoritmen Flytter to hakk. Ikke match

17 KMP-algoritmen Flytter tre hakk. Her er det hvertfall match på den delen der de var like i forrige sammenlikning Vi kan altså flytte forbi alle situasjoner der det vi vet om T (ut fra den delen som stemte med P) ikke stemmer med det vi vet om P Det kan hende at vi aldri får slik match som på figuren over, og da kan vi flytte P slik at starten er der det ble forskjell i forrige søk. Dette, altså lange flytt, er det beste for effektiviteten av algoritmen.

18 KMP-algoritmen 0 1 i - d j i j -1 j j -2 j j - d j d j d j er lengden av lengste suffix av P [1 : j -1] som også er prefix av P [0 : j - 2] Vi vet nå at om vi flytter P mindre enn j - d j steg, så kan det ikke bli match. Og vi vet at etter flytting P [0: d j -1] matcher T, så vi kan starte å sammenlikne ved P [d j : m-1].

19 Knuth-Morris-Pratt-algoritmen Plan Vi vil lage en heltalls-tabell Next[0:m-1] som viser hvor langt vi kan flytte P når vi får en mismatch på stedet j i P, j = 0,1,2,, m-1 Men Next angir ikke dette direkte, men i stedet den nye (og mindre) verdien som j skal ha når vi fortsetter søket. Altså: Next[j] = j <antall steg P kan flyttes fram> Eller: Next[j] er det som er betegnet med d j på forrige foil Og etter flytting vil også de d j første som vi ser på i T stemme med de tilsvarende i P. Det var slik vi valgte d j. Og Next-arrayen kan altså beregnes ut fra bare innholdet i P

20 function KMPStringMatcher (P [0:m -1], T [0:n -1]) i 0 // indeks i T j 0 // indeks i P CreateNext(P [0:m -1], Next [n -1]) while i < n do if P [ j ] = T [ i ] then if j = m 1 then // sjekker om full match else endif i i +1 j j +1 return(i m + 1) j Next [ j ] if j = 0 then if T [ i ] P [0] then i i +1 endif endif endif endwhile return(-1) end KMPStringMatcher Worst case tid: O(n) Knuth-Morris-Pratt-algoritmen Denne if-setningen er med for å forhindre at algoritmen går i evig løkke. Om den ikke er med kan P bli «stående på samme sted» runde etter runde, uten at i blir øket.

21 Knuth-Morris-Pratt-algoritmen Vi må altså skrive en funksjon som finner Next ut fra P: function CreateNext (P [0:m -1], Next [0:m -1]) end CreateNext Denne kan skrives rett fram ved enkel søking, og vil da bruke tid O(m 2 ). Man kan imidlertid bruke noen av de samme triksene som når man går fra den naive søkealgoritmen, til KMP-algoritmen, og da kan man finne Next-arrayen i tid O(m). Det er den kompliserte som står i boka, men vi tar ikke den med som pensum.

22 Knuth-Morris-Pratt-algoritmen Eksempel Next-arrayen til P-en over : j = Next[j] =

23 Knuth-Morris-Pratt-algoritmen Next-arrayen til P-en over : j = Next[j] =

24 Knuth-Morris-Pratt-algoritmen Next-arrayen til P-en over : j = Next[j] =

25 Knuth-Morris-Pratt-algoritmen Next-arrayen til P-en over : j = Next[j] =

26 Knuth-Morris-Pratt-algoritmen Next-arrayen til P-en over : j = Next[j] = Lineær algoritme, O(n) kjøretid worst case.

27 Boyer-Moore-algoritmen (Horspool) Den naive algoritmen, og Knuth-Morris-Pratt er prefiksbaserte (fra venstre mot høyre). Boyer-Moore-algoritmen (og varianter) er suffixbasert (fra høyre mot venstre i patternet). Horspool laget en forenkling av Boyer-Moore, og det er den vi skal se på her Vi ser på følgende eksempel: B M m a t c h e r _ s h i f t _ c h a r a c t e r _ e x c h a r a c t e r

28 Boyer-Moore-algoritmen (Horspool) Sammenlikner bakfra i P B M m a t c h e r _ s h i f t _ c h a r a c t e r _ e x c h a r a c t e r

29 Boyer-Moore-algoritmen (Horspool) Den naive algoritmen, og Knuth-Morris-Pratt er prefiksbaserte (fra venstre mot høyre). Boyer-Moore-algoritmen (og varianter) er suffixbasert (fra høyre mot venstre i patternet). B M m a t c h e r _ s h i f t _ c h a r a c t e r _ e x c h a r a c t e r c h a r a c t e r

30 Boyer-Moore-algoritmen (Horspool) B M m a t c h e r _ s h i f t _ c h a r a c t e r _ e x c h a r a c t e r c h a r a c t e r c h a r a c t e r

31 Boyer-Moore-algoritmen (Horspool) B M m a t c h e r _ s h i f t _ c h a r a c t e r _ e x c h a r a c t e r c h a r a c t e r c h a r a c t e r c h a r a c t e r

32 Boyer-Moore-algoritmen (Horspool) B M m a t c h e r _ s h i f t _ c h a r a c t e r _ e x c h a r a c t e r c h a r a c t e r c h a r a c t e r c h a r a c t e r O(mn) kjøretid worst case (som den naive algoritmen). Sub-lineær ( n) i gjennomsnitt O(n (log A m) / m).

33 Boyer-Moore-algoritmen (Horspool) function HorspoolStringMatcher (P [0:m -1], T [0:n -1]) i 0 CreateShift(P [0:m -1], Shift [0: A - 1]) while i < n m do j m 1 while j 0 and T [ i+j]=p [ j ] do j j -1 endwhile if j = 0 then return( i ) endif i i + Shift[ T[ i + m -1] ] endwhile return(-1) end HorspoolStringMatcher

34 Funksjonen CreateShift Boyer-Moore-algoritmen (Horspool) function CreateShift (P [0:m -1], Shift [0: A - 1]) end HorspoolStringMatcher Vi må altså lage Shift-arrayen, som er like lang som alfabetet Vi leter da bakfra (ikke ta med helt bakerste tegn i P) og registrerer indeksen der de forskjellige tegnene opptrer første gang. For tegnene t som ikke opptrer i P setter vi Shift[t] = <lengden av P>. Det gir altså fult skift

35 Karp-Rabin-algoritmen Vi antar at strengene våre kommer fra et k-ært alfabet A = {0, 1, 2,, k -1}. Hvert symbol i A kan sees på som et siffer i k-tallssystemet. Hver streng S i A* kan sees på som tall S i k-tallssystemet. Eks: k = 10, og A = {0,1, 2,, 9} (Det vanlige 10-tallssystemet) Strengen kan sees på som tallet Gitt en streng P [0:m -1], kan vi beregne det korresponderende tallet P med m multiplikasjoner og m addisjoner (Horners regel): P = P [m -1]+k(P [m -2]+ +k(p [1] + kp [0])...)) Eks: 1234 = (3 + 10(2 + 10*1))

36 Karp-Rabin-algoritmen Gitt en tekststreng T [0:n -1], og et heltall s (start-index), bruker vi T s som en hash-verdi for delstrengen T [s: s + m -1]. (Vi antar at patternet vårt har lengde m.) En algoritme basert på Horners regel beregner T 0, T 1, T 2, og sammenlikner disse tallene med tallet P for patternet P. (Tilsvarende den naive algoritmen.)

37 Karp-Rabin-algoritmen Gitt en tekststreng T [0:n -1], og et heltall s (start-index), bruker vi T s som betegnelse på delstrengen T [s: s + m -1]. (Vi antar at patternet vårt har lengde m.) En algoritme basert på Horners regel beregner T 0, T 1, T 2, og sammenlikner disse tallene med tallet P for patternet P. (Tilsvarende den naive algoritmen.) Gitt T s -1 og k m 1, kan vi regne ut T s i konstant tid.

38 Karp-Rabin-algoritmen Gitt en tekststreng T [0:n -1], og et heltall s (start-index), bruker vi T s som betegnelse på delstrengen T [s: s + m -1]. (Vi antar at patternet vårt har lengde m.) En algoritme basert på Horners regel beregner T 0, T 1, T 2, og sammenlikner disse tallene med tallet P for patternet P. (Tilsvarende den naive algoritmen.) Gitt T s -1 og k m 1, kan vi regne ut T s i konstant tid s-1 s -1+ m -1 n -1 T [0:n -1] T s -1

39 Karp-Rabin-algoritmen Gitt en tekststreng T [0:n -1], og et heltall s (start-index), bruker vi T s som betegnelse på delstrengen T [s: s + m -1]. (Vi antar at patternet vårt har lengde m.) En algoritme basert på Horners regel beregner T 0, T 1, T 2, og sammenlikner disse tallene med tallet P for patternet P. (Tilsvarende den naive algoritmen.) Gitt T s -1 og k m 1, kan vi regne ut T s i konstant tid.! s-1 s s + m -1 n -1 T [0:n -1] T s

40 Karp-Rabin-algoritmen Grunnen til at vi kan beregne T s følgende rekurrensrelasjon: i konstant tid når vi har T s -1 og k m 1, er T s = k(t s -1 - k m 1 *T [s]) + T [s+m] s = 1,, n m Konstant, beregnes en gang, kan gjøres i tid O(log m) Eks: k = 10, A = {0,1, 2,, 9} (Det vanlige 10-tallssystemet) og m = 7. T s -1 = T s = T s = 10( ( * 7)) + 8 Kan gjøres i konstant tid. Bare multiplikasjon og addisjon, vi antar disse operasjonene kan gjøres i konstant tid. Dette blir jo hvertfall sant når vi senere går over til modulo-regning.

41 Karp-Rabin-algoritmen Kan beregne T s i konstant tid når vi har T s -1 og k m 1. Altså kan vi beregne de n m + 1 tallene T s, s = 0, 1,, n m og P itido(n). Vi kan altså, i teorien, implementere en søkealgoritme med kjøretid O(n). Dessverre vil tallene T s og P i praksis være for store til at algoritmen blir praktisk anvendbar. Trikset er å bruke modulo-aritmetikk. Vi gjør alle beregninger modulo q (q er valgt som et primtall, slik at kq akkurat passer i et 32/64 bits register). Primtall blir valgt fordi det fordeler hash-verdiene godt.

42 Vi beregner T (q) s og P (q), hvor Karp-Rabin-algoritmen T (q) s = T s mod q, P (q) = P mod q, } Resten i divisjonen, når vi deler på q: et tall i intervallet {0, 1,, q -1}. og sammenlikner. Vi kan ha T (q) s = P (q), selv om T s P, en såkalt spuriøs match. Har vi T (q) s = P (q), må vi altså gjøre en nøyaktig sjekk av T s og P. Med stor nok q, er sannsynligheten for spuriøse matcher lav.

43 Karp-Rabin-algoritmen function KarpRabinStringMatcher (P [0:m -1], T [0:n -1], k, q) c k m -1 mod q P (q) 0 T (q) s 0 for i 1 to m do P (q) (k * P (q) + P [ i ]) mod q T (q) 0 (k * T (q) 0 + T [ i ]) mod q endfor for s 0 to n - m do if s > 0 then T (q) s (k * ( T (q) s -1 -T[ s ] * c) + T [ s + m ]) mod q endif if T (q) s = P (q) then if T s = P then return(s) endif endif endfor return(-1) end KarpRabinStringMatcher

44 Karp-Rabin-algoritmen Lengste kjøretid for Karp-Rabin-algoritmen får vi når patternet P finnes helt i slutten av strengen T. Sannsynligheten for at T (q) s antar en spesifikk verdi i intervallet {0, 1,, q-1} er uniform 1/q. (Vi antar strengene er uniformt fordelte.) T (q) s, s = 0, 1,, n-m-1 vil for hver s altså gi opphav til en spuriøs match med sannsynlighet 1/q (altså at vi får like hash-verdier uten at strengene er like). La r være det forventede antall spuriøse matcher. Hver av disse innebærer inntil m sammenlikninger. I tillegg må vi sjekke T (q) n-m, hvor vi til slutt får ekte match. Kjøretiden blir altså: O( (r + 1)m + (n m + 1) )

45 Karp-Rabin-algoritmen (konklusjon) Om patternet P ikke finnes i T eller ligger helt på slutten av T (worst case) vil verdien av r med stor sannsynlighet ligge nær (n-m) * (1/q) Totalt får vi altså at max kjøretid blir: n m q O( 1 m ( n m 1) ) Slik vi valgte q er det rimelig å anta at q >> m, og da blir kjøretiden altså O(n).

46 Mange søk i samme strengen T Da kan det være lurt å preprosessere T Slik Google preprosserer de sidene den leser, for å kunne søke raskt i dem siden. Dette kalles også å «indeksere» en datamengde Vi gjør vår indeksering ved å lage et «suffiks-tre» Ofte er det slik at vi kan legge inn ny informasjon i datamengden (f.eks. forlenge T), og justere indekseringen etter forandringen. Dette gjøres typisk i Google etter hvert som den leser nye sider

47 Først: Trie-trær a i w Trykkfeil i boka l n e o g l t b r o e l r r d i t h m a l l n e t v l e w y

48 Trie-trær al inter w gorithm l n view eb orld ally et

49 Suffix-trær Suffix tre for babbage a b e ge bbage ge a bage bbage ge

50 Div.