Algorytmy i struktury danych/Algorytmy tekstowe I

Algorytmy tekstowe I

Tekst jest ciągiem symboli. Przyjmujemy, że jest on zadany tablicą $x[1,\ldots ,n]$, elementami której są symbole ze skończonego zbioru A (zwanego alfabetem). Liczba $n=|x|$ jest długością (rozmiarem) tekstu. W większości naszych algorytmów jedyne operacje dopuszczalne na symbolach wejściowych, to porównania dwóch symboli.

Algorytmy na tekstach wyróżniają się tym, że wykorzystują specyficzne, kombinatoryczne własności tekstów. Okresem tekstu $x$ jest każda liczba naturalna niezerowa $p$ taka, że $x[i]=x[i+p]$, dla każdego $i$, dla którego obie strony są zdefiniowane. Przez per(x) oznaczmy minimalny okres x.

Pojęciem dualnym do okresu jest prefikso-sufiks tekstu. Jest to najdłuższy właściwy (nie będący całym tekstem) prefiks tekstu x będący jednocześnie jego sufiksem. Oczywiste jest, że $|x|-per(x)$ jest długością prefikso-sufiksu x. Jeśli $per(x)=|x|$ to prefikso-sufiksem x jest słowo puste o długości zerowej.

Oznaczmy przez $P[k]$ rozmiar prefikso-sufiksu $x[1..k]$; zatem $per(x)=n-P[n]$, gdzie $n=|x|$.

Przykład

Dla $x\ =\ abababababb$ mamy:

$P[1..11]\ =\ [0,\ 0,\ 1,\ 2,\ 3,\ 4,\ 5,\ 6,\ 7,\ 8,\ 0].$

Wartość $P[0]$ jest wartością sztuczną (przyjmiemy potem $P[0]=-1$).

Obliczanie tablicy Prefikso-Sufiksów

Przedstawimy jeden z możliwych algorytmów liniowych obliczania tablicy P. Jest to iteracyjna wersja algorytmu rekurencyjnego, który moglibyśmy otrzymać korzystając z faktu:

Jeśli $x[j]=x[t+1]$ oraz $t=P[j-1]<math>,to<math>P[j]=t+1$

W algorytmie obliczania $P[j]$ korzystamy z wartości $P[k]$, dla $k<j$.

Algorytm Prefikso-Sufiksy

---

1  $P[0]:=-1$; $t:=0$;
2  for $j:=1$ to $m$ do
3   begin
4    while $t\geq 0$ and $x[t+1]\neq x[j]$ do $t:=P[t];$
5    $t:=t+1$; $P[j]:=t$;
6   end;

Złożoność liniowa wynika stąd, że w każdej iteracji zwiększamy wartość t co najwyżej o jeden, a wykonanie każdej operacji $t:=P[t]$ zmniejsza wartość t co najmniej o jeden. Proste zastosowanie zasady magazynu (lub potencjału) implikuje, że operacji $t:=P[t]$ wykonujemy co najwyżej n. Dowód poprawności pozostawiamy jako ćwiczenie.

Minimalne słowo pokrywające

Pokażemy pewne, proste zastosowanie tablic prefikso-sufiksów. Słowem pokrywającym tekst x jest każdy taki tekst y, którego wystąpienia w x pokrywają cały tekst x. Na przykład słowo y=aba pokrywa tekst x=ababaaba, natomiast nie pokrywa tekstu abaaababa. Zajmiemy się problemem: obliczyć w czasie liniowym długość najkrótszego słowa pokrywającego dany tekst x.

Niech $S[i]$ będzie rozmiarem minimalnego słowa pokrywającego dla prefiksu $x[1..i]$. Następujący algorytm oblicza długość minimalnego słowa pokrywającego tekstu x. Obliczamy wartości $S[i]$ długości najkrótszego słowa pokrywającego $x[1\ldots i]$ dla każdego $1\leq i\leq n$. W $i$-tej iteracji algorytmu pamiętany jest znany zakres każdego minimalnego słowa pokrywającego.

TODO - problem z rysunkiem, napis nie pasuje do podpisu, co to jest q?

Rysunek 3: $i$-ta iteracja algorytmu dla $i=15$ oraz słowa $x\ =\ abaabababaababa\ldots$. Tuż przed rozpoczęciem tej iteracji mamy $P[i]=8$, $q=S[8]=3$, $Zakres[3]=13$. Po zakończeniu $i$-tej iteracji

mamy $S[15]=3,Zakres[3]=15$, ponieważ $i-Zakres[3]\leq q$.

Algorytm Rozmiar-Minimalnego-Pokrycia

---

1  for  $i:=2$ to $n$ do begin
2    $Zakres[i]=i;S[i]=i;$
3  end;
4  for  $i:=2$ to $n$ do
5    if $P[i]>0$ and $i-Zakres[S[P[i]]\leq S[P[i]]$ then begin
6      $S[i]:=S[P[i]]$;  $Zakres[S[P[i]]:=i$;

7    end;
8  return $S[n]$;

Poprawność jest pozostawiona jako ćwiczenie.

Tablica Silnych Prefikso-Sufiksów

TODO - KDX - ???

Wprowadzimy silną tablicę prefikso-sufiksów dla wzorca $x[1..m]$: jeśli $j<|x|$, to $P'[j]=k$, gdzie $k$ jest maksymalnym rozmiarem słowa będącego właściwym prefiksem i sufiksem $x[1..j]$ i spełniającego dodatkowy warunek $x[k+1]\neq x[j+1]$ dla $j<n$.
Jeśli takiego k nie ma, to przyjmujemy $P'[j]=-1$. Przyjmujemy ponadto, że $P'[m]=P[m]$.

Wartości tablicy P' mogą być znacznie mniejsze niż wartości tablicy P.

Przykład

Dla $x\ =\ abaab$ mamy:

$P[0..5]\ =\ [-1,\ 0,\ 0,\ 1,\ 1,\ 2\ ];\ \ P'[0..5]\ =\ [-1,\ 0,\ -1,\ 1,\ 0,\ 2\ ].$

Algorytm bazuje na następującej relacji między P a P':

$(t=P[j]\ {\textrm {oraz}}\ x[t+1]\neq x[j+1])\ \Rightarrow \ P'[j]=t$

$(t=P[j],\ t\geq 0,\ {\textrm {oraz}}\ x[t+1]=x[j+1])\ \Rightarrow \ P'[j]=P'[t]$

Nie musimy obliczać tablicy P; potrzebna jest jedynie ostatnia wartość $t=P[j]$, którą obliczamy on-line.

Algorytm Silne-Prefikso-Sufiksy

---

1  $P'[0]:=-1$; $t:=-$1;
2  for $j:=$ 1 to $m$ do begin // $t=P[j-1]$ 
3    while $t\geq 0$ and $x[t+1]\neq x[j]$do
4       $t:=P'[t]$;
5    $t:=t+1$;
6    if $j=m$ or $x[t+1]\neq x[j+1]$
7      then $P'[j]:=t$ else $P'[j]:=P'[t]$;
8  end;

Gdy weźmiemy $x\ =\ aba^{m-2}$ to $P'[0]=-1$, $P'[1]=0$, $P'[2]=-1$, oraz $P'[j]=1$ dla $3\leq j\leq m$. To jest pesymistyczny przypadek dla algorytmu Silne-Prefikso-Sufiksy, algorytm wykonuje $3m-5$ porównań symboli.

String-matching: algorytm Knutha-Morrisa-Pratta

Przedstawimy klasyczny algorytm Knutha-Morrisa-Pratta (w skrócie KMP) dla problemu string-matchingu:   obliczyć w w tekście $y$ wszystkie (lub pierwsze) wystąpienia danego tekstu $x$, zwanego wzorcem.

Oznaczmy $m=|x|,n=|y|$, gdzie $m\leq n$.

Operacją dominującą w algorytmie jest porównanie dwóch symboli.

Zaczniemy od obliczania jedynie pierwszego wystąpienia. Algorytm KMP przegląda tekst y od lewej do prawej, sprawdzając, czy jest zgodność na pozycji $j+1$ we wzorcu x oraz na pozycji $i+j+1$ w tekście y. Jeśli jest niezgodność, to przesuwamy potencjalny początek (pozycja i) wystąpienia x w y. Zakładamy, że algorytm zwraca na końcu wartość false,jeśli nie zwróci wcześniej true. Pozostawiamy dowód poprawności (określenie niezmienników) jako ćwiczenie.

Algorytm Algorytm KMP

---

1  $i:=0$; $j:=0$;
2  while $i\leq n-m$ do begin
3    while $j<m$ and $x[j+1]=y[i+j+1]$ do $j=j+1$;
4    if $j=m$ then return(true);
5    $i:=i+j-P'[j]$; $j:=\max(0,P'[j])$
6  end;

Operacją dominującą w algorytmie jest operacja: $x[j+1]=y[i+j+1]$.

Udowodnimy, że algorytm KMP wykonuje co najwyżej 2n-m porównań symboli. Zauważmy, że dla danej pozycji w tekście y jest ona co najwyżej raz porównana z pewną pozycją we wzorcu w porównaniu pozytywnym (gdy symbole są równe). Jednocześnie każde negatywne porównanie powoduje przesunięcie pozycji $i$ co najmniej o jeden, maksymalna wartość i wynosi n-m, zatem mamy takich porównań co najwyżej n-m, w sumie co najwyżej 2n-m porównań w algorytmie KMP.

<flash>file=KMP.swf|width=450|height=220</flash>

Algorytm dla $x=ab$, $y=aa..a$ wykonuje 2n-2porównania, zatem 2n-m jest dolną i jednocześnie górną granicą na liczbę porównań w algorytmie.

Obserwacja. Tablicę P' możemy w algorytmie KMP zamienić na P bez zmiany złożoności pesymistycznej.

W wersji on-line algorytmu okaże się, że jest zdecydowana różnica między użyciem P' i P; to właśnie jest motywacją dla wprowadzenia silnych prefikso-sufiksów.

Rysunek 1: Jedna iteracja algorytmu KMP. Przesunięcie $shift=j-P'[j]$ potencjalnego początku wystąpienia wzorca gdy $x[j+1]\neq y[i+j+1]$.

Wersja on-line algorytmu KMP

Przedstawimy teraz wersję on-line algorytmu KMP. Wczytujemy kolejne symbole $y$ i wypisujemy on-line (na bieżąco) odpowiedź:

• 0 - gdy dotychczas wczytany tekst nie zawiera x jako sufiks,
• 1 - jeśli zawiera

Algorytm On-Line-KMP

---

1  repeat forever
2    read($symbol$);
3    while $j>-1$ and $x[j+1]\neq symbol$ do $j:=P'[j]$;
4    $j:=j+1$;
5    if $j=m$ then 
6      write(1); $j:=P'[m]$;
7    else write(0);

Oznaczmy przez delay(m) maksymalną liczbę kroków algorytmu On-Line-KMP między wczytaniem symbolu i daniem odpowiedzi. Przez delay'(m) oznaczmy podobną wielkość, w sytuacji gdy zamiast tablicy P' użyjemy P.

Przykład

Jeśli $x=aaaa\dots a$ oraz $y=a^{m-1}b$, to $delay(m)=O(1)$, $delay'(m)=\Theta (m)$.

Z lematu o okresowości wynika, że zachodzi następujący fakt:

$delay(m)\ =\ \Theta (\log m)$

Uzasadnienie pozostawiamy jako ćwiczenie.

Wersja real-time algorytmu KMP

Pokażemy teraz wersję algorytmu on-line, która działa w czasie rzeczywistym, tzn. czas reakcji między wczytaniem symbolu a daniem odpowiedzi jest O(1), niezależnie od rozmiaru alfabetu.

Algorytm zachowuje się podobnie jak algorytm On-Line-KMP; podstawowa różnica polega na tym, że algorytm wkłada do kolejki wczytane symbole, które jeszcze nie są przetworzone w sensie algorytmu KMP. Algorytm zachowuje się podobnie jak algorytm on-line, ale wczytuje kolejne symbole z kolejki, a nie bezpośrednio z wejścia. Rysunek pokazuje relacje tego algorytmu do algorytmu KMP. Symbole z wejścia najpierw wędrują do kolejki.

Rysunek 2: Typowa konfiguracja w algorytmie real-time-KMP.

Algorytm Real-Time-KMP

---

1  inicjalizacja:  $j:=0$; Kolejka ${\displaystyle :=\emptyset }$;
2  repeat forever
3    read(symbol);
4    insert(symbol,Kolejka); 
5    write(OUTPUT(Kolejka, j));

W celu skrócenia zapisów pojedynczych algorytmów rozbijamy algorytm na dwie części. Zasadnicza część jest zapisana jako osobna funkcja OUTPUT(Kolejka, j). Funkcja ta liczy 0 lub 1, w zależności od tego czy ostatnio wczytany symbol kończy wystąpienie wzorca x. Zmienne Kolejka, j są globalne.

Oczywiste jest, że opóźnienie (czas reakcji) tego algorytmu jest O(1).

Pozostawiamy jako ćwiczenie uzasadnienie tego, że algorytm Real-Time-KMP jest poprawny.

Algorytm Real-Time-KMP: funkcja OUTPUT(Kolejka, j)

---

1  output ${\displaystyle :=}$ 0;
2  repeat 2 times
3    if  Kolejka niepusta then
4      if $j=-1$ then 
5        j ${\displaystyle :=}$ 0; delete(Kolejka);
6      else if  $x[j+1]\neq first(Kolejka)$ then   $j:=P'[j]$;
7      else 
8        $j:=j+1$; delete(Kolejka); 
9      if $j=m$
10       output ${\displaystyle :=}$1; j ${\displaystyle :=P'[m]}$; 
11 return(output);

Wersja algorytmu KMP z ${\frac {3n}{2}}$ porównaniami

Algorytm KMP wykonuje co najmniej 2n-m porównań symboli. Załóżmy, że są to operacje dominujące i spróbujmy zmniejszyć stały współczynnik 2 do ${\frac {3}{2}}$. Na początku załóżmy, że $x=ab$. Następujący algorytm znajduje wszystkie wystąpienia wzorca ab w tekście y.

Algorytm Szukanie-ab

---

1  wzorcem jest $ab$ 
2  $i:=0$; 
3  while $i\leq n-m$ do begin
4    while $y[i+2]\neq b$ do$i=i+1$;
5    if $y[i+1]=a$ then 
6      wypisz-wystąpienie;i${\displaystyle :=}$i+2
7  end;

Algorytm KMP dla wzorca ab wykonywał 2n-2 porównań symboli, nowy algorytm jest lepszy. Zachodzi fakt:     algorytm Szukanie-ab wykonuje co najwyżej n porównań w tym przypadku.

Uzasadnienie pozostawiamy jako ćwiczenie.

Uogólnimy algorytm na dowolne wzorce. Niech x zawiera co najmniej dwa różne symbole, $x=a^{k}b\alpha$, gdzie $a\neq b$.Oznaczmy $x'=b\alpha$ skrócony wzorzec

Przykład

$x\ =\ aaaabaaaababa$, wtedy $x'\ =\ baaaababa$, $\alpha \ =\ aaaababa$.

Podamy nieformalny zarys działania oszczędniejszej wersji algorytmu KMP, w której osobno szukamy x' i osobno części $a^{k}$.

Niech $KMP'$ będzie taką wersją algorytmu KMP, w której szukamy jedynie wzorca $x'$, ale tablica $P'$ jest obliczona dla wzorca $x$. Jeśli $j>0$ i $shift\leq k$, to wykonujemy przesunięcie potencjalnego początku i wzorca w y o k+1, gdzie $shift=j-P'[j]$. Inaczej mówiąc, nie szukamy wszystkich wystąpień x', ale jedynie takich, które mają sens z punktu widzenia potencjalnego znalezienia na lewo ciągu $a^{k}$.

Tak zmodyfikowany algorytm KMP zastosujemy jako część algorytmu Oszczędny-KMP. Graficzna ilustracja działania algorytmu Oszczędny-KMP jest pokazana na rysunku.

Algorytm Oszczędny-KMP

---

Znajdujemy wystąpienia x' w tekście $y[k+1..m]$ algorytmem KMP';
dla każdego wystąpienia x' sprawdzamy, czy na lewo jest wystąpienie $a^{k}$;
nie sprawdzamy tych pozycji w y, których zgodność z pewną pozycją w x jest znana;

Rysunek 3:Typowa konfiguracja w algorytmie Oszczędny-KMP.

Pozostawiamy jako ćwiczenie dokładny zapis algorytmu w pseudokodzie oraz dowód tego, że algorytm Oszczędny-KMP wykonuje co najwyżej ${\frac {3}{2}}n$ porównan.

Ogólna idea jest przedstawiona na rysunku.

Rysunek 4: Ilustracja tego, że liczba operacji dodatkowych jest ograniczona przez ${\frac {1}{2}}n$.

Niech zasadniczymi operacjami będą operacje sprawdzania pierwszego b na danej pozycji tekstu y, oraz te sprawdzania symboli które sa z wynikiem pozytywnym. Takich operacji jest co najwyżej n. Pozostałe operacje to

(1) sprawdzanie w części $\alpha$ z wynikiem negatywnym; wtedy przesuwamy wzorzec co najmniej o k,

(2) sprawdzanie części $a^{k}$ na lewo od pozytywnego $b$ (w kwadraciku na rysunku), na pozycjach gdzie wcześniej było sprawdzanie negatywnego b. Wtedy odległość między pozytywnymi kolejnymi b jest co najmniej 2w, gdzie $w\leq k$ liczba sprawdzanych na lewo symboli a. Zatem lokalnie przesunięcie jest co najmniej dwukrotnie większe niż liczba dodatkowych operacji.

Suma przesunięć wzorca na tekście $y$ wynosi co najwyżej n, tak więc sumaryczna liczba dodatkowych operacji jest co najwyżej ${\frac {1}{2}}n$, a liczba wszystkich operacji nie przekracza ${\frac {3}{2}}n$.

Równoważność cykliczna słów

W poprzednich algorytmach porównywaliśmy symbole jedynie w sensie ich równości. Pokażemy teraz problem, który pokazuje użyteczność porządku liniowego na alfabecie.

Rotacją słowa $u=u[1..n]$ jest każde słowo postaci $u^{(k)}\ =\ u[k+1..n]u[1..k]$. (W szczególności $u^{(0)}=u^{(n)}=u)$. Niech $u,w$ będą słowami długości $n$; mówimy, że są one cyklicznie równoważne, gdy $u^{(i)}=w^{(j)}$ dla pewnych $i,j$.

Naturalnym algorytmem sprawdzania cyklicznej równoważności jest szukanie słowa $u$ w słowie $ww$, ale podamy algorytm znacznie prostszy bazujący na porządku leksykograficznym, który będzie działał w czasie liniowym i w miejscu (dodatkowa pamięć jest stała).

W algorytmie rozszerzamy tablice $u,w$ na $uu,\ ww$ ale robimy to jedynie dla uproszczenia, w rzeczywistości możemy poruszać się cyklicznie po $u$ i po $w$; modyfikację pozostawiamy jako ćwiczenie.

Algorytm Równoważność-Cykliczna

---

1  $x:=uu$; $y:=ww$;
2  $i:=0$; $j:=0$;
3  while $(i<n)$ and $(j<n)$ do begin
4    $k:=1$;
5    while $x[i+k]=y[j+k]$ do $k:=k+1$;
6    if $k>n$ then return true;
7    if $x[i+k]>y[i+k]$ then $i:=i+k$ else $j:=j+k$;
8  end;
9  return false;

Problem poprawności pozostawiamy jako ćwiczenie.

Liczba porównań jest oczywiście liniowa. Pozostawiamy jako ćwiczenie wyprowadzenie dokładnego wzoru na maksymalną liczbę porównań symboli dla tekstów długości $n$.