Z-функция — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Описание алгоритма)
(Построение Z-функции по префикс-функции)
Строка 128: Строка 128:
 
[[Файл:Case three.png|300px|thumb|right|'''Случай третий''']]
 
[[Файл:Case three.png|300px|thumb|right|'''Случай третий''']]
 
=== Постановка задачи ===
 
=== Постановка задачи ===
Дан массив с корректной [[Префикс-функция | префикс-функцией]] для строки <tex>s</tex>, получить за <tex>O(n)</tex> массив с Z-функцией для строки <tex>s</tex>.
+
Дан массив с корректной [[Префикс-функция | префикс-функцией]] для строки <tex>s</tex>, получить массив с Z-функцией для строки <tex>s</tex>.
 
<br>
 
<br>
 
===Описание алгоритма===  
 
===Описание алгоритма===  
Строка 155: Строка 155:
  
 
===Псевдокод===
 
===Псевдокод===
  '''int[]''' buildZFunctionFromPrefixFunction('''int'''[] P)
+
  '''int[]''' buildZFunctionFromPrefixFunction(P : '''int'''[])
  '''int''' n = P.length;
+
   '''int'''[] Z = '''int'''[n]
   '''int'''[] Z = new '''int'''[n]
+
   '''for''' i = 1 '''to''' n - 1
   '''for'''('''int''' i = 1; i < n; i++)
+
       '''if''' P[i] > 0
       '''if'''(P[i])
 
 
         Z[i - P[i] + 1] = P[i]
 
         Z[i - P[i] + 1] = P[i]
   Z[0] = n;
+
   Z[0] = n
 
   '''int''' t
 
   '''int''' t
   '''for'''('''int''' i = 1; i < n - 1; i++)
+
   '''for''' i = 1 '''to''' n - 1
       t = i;
+
       t = i
       '''if'''(Z[i])
+
       '''if''' Z[i] > 0
         '''for'''('''int''' j = 1; j < Z[i] && Z[i + j] <= Z[j]; j++)
+
         '''for''' j = 1 '''to''' Z[i] - 1
 +
            '''if''' Z[i+j] > Z[j]
 +
              '''break'''
 
             Z[i + j] = min(Z[j], Z[i] - j)
 
             Z[i + j] = min(Z[j], Z[i] - j)
 
             t = i + j
 
             t = i + j

Версия 16:37, 14 апреля 2016

Определение:
Z-функция (англ. Z-function) от строки [math]S[/math] и позиции [math]x[/math] — это длина максимального префикса подстроки, начинающейся с позиции [math]x[/math] в строке [math]S[/math], который одновременно является и префиксом всей строки [math]S[/math]. Более формально, [math]Z[i](s) = \max k \mid s[i\, \mathinner{\ldotp\ldotp}\, i + k] = s[0 \mathinner{\ldotp\ldotp} k][/math]. Значение Z-функции от первой позиции не определено, поэтому его обычно приравнивают к нулю или к длине строки.

Примечание: далее в конспекте символы строки нумеруются с нуля.

Строка и её Z-функция

Тривиальный алгоритм

Простая реализация за [math]O(n^2)[/math], где [math]n[/math] — длина строки. Для каждой позиции [math]i[/math] перебираем для неё ответ, начиная с нуля, пока не обнаружим несовпадение или не дойдем до конца строки.

Псевдокод

 int[] zFunction(s : string):
   int[] zf = int[n]
   for i = 1 to n − 1
     while i + zf[i] < n and s[zf[i]] == s[i + zf[i]]
       zf[i]++
   return zf

Эффективный алгоритм поиска

Z-блоком назовем подстроку с началом в позиции [math]i[/math] и длиной [math]Z[i][/math].
Для работы алгоритма заведём две переменные: [math]left[/math] и [math]right[/math] — начало и конец Z-блока строки [math]S[/math] с максимальной позицией конца [math]right[/math] (среди всех таких Z-блоков, если их несколько, выбирается наибольший). Изначально [math]left=0[/math] и [math]right=0[/math]. Пусть нам известны значения Z-функции от [math]0[/math] до [math]i-1[/math]. Найдём [math]Z[i][/math]. Рассмотрим два случая.

  1. [math]i \gt right[/math]:
    Просто пробегаемся по строке [math]S[/math] и сравниваем символы на позициях [math]S[i+j][/math] и [math]S[j][/math].Пусть [math]j[/math] первая позиция в строке [math]S[/math] для которой не выполняется равенство [math]S[i+j] = S[j][/math], тогда [math]j[/math] это и Z-функция для позиции [math]i[/math]. Тогда [math]left = i, right = i + j - 1[/math]. В данном случае будет определено корректное значение [math]Z[i][/math] в силу того, что оно определяется наивно, путем сравнения с начальными символами строки.
  2. [math]i \leqslant right[/math]:
    Сравним [math]Z[i - left] + i[/math] и [math]right[/math]. Если [math]right[/math] меньше, то надо просто наивно пробежаться по строке начиная с позиции [math]right[/math] и вычислить значение [math]Z[i][/math]. Корректность в таком случае также гарантирована.Иначе мы уже знаем верное значение [math]Z[i][/math], так как оно равно значению [math]Z[i - left][/math].

Z-func.png

Время работы

Этот алгоритм работает за [math]O(|S|)[/math], так как каждая позиция пробегается не более двух раз: при попадании в диапазон от [math]left[/math] до [math]right[/math] и при высчитывании Z-функции простым циклом.

Псевдокод

 int[] zFunction(s : string):
   int[] zf = int[n]
   int left = 0, right = 0
   for i = 1 to n − 1
     zf[i] = max(0, min(right − i, zf[i − left]))
     while i + zf[i] < n and s[zf[i]] == s[i + zf[i]]
       zf[i]++
     if i + zf[i] >= right
       left = i
       right = i + zf[i]
   return zf

Поиск подстроки в строке с помощью Z-функции

[math]n[/math] — длина текста. [math]m[/math] — длина образца.
Образуем строку s = pattern + # + text, где # — символ, не встречающийся ни в text, ни в pattern. Вычисляем Z-функцию от этой строки. В полученном массиве, в позициях в которых значение Z-функции равно [math]|\texttt{pattern}|[/math], по определению начинается подстрока, совпадающая с pattern.

Псевдокод

 int substringSearch(text : string, pattern : string):
   int[] zf = zFunction(pattern + '#' + text)
   for i = m + 1 to n + 1
     if zf[i] == m 
       return i


Построение строки по Z-функции

Задача:
Восстановить строку по Z-функции за [math]O(n)[/math], считая алфавит ограниченным.


Описание алгоритма

Пусть в массиве [math]z[/math] хранятся значения Z-функции, в [math]s[/math] будет записан ответ. Пойдем по массиву [math]z[/math] слева направо.

Нужно узнать значение [math]s[i][/math]. Для этого посмотрим на значение [math]z[i][/math]: если [math]z[i] = 0[/math], тогда в [math]s[i][/math] запишем ещё не использованный символ или последний использованный символ алфавита, если мы уже использовали все символы. Если [math]z[i] \neq 0[/math], то нам нужно записать префикс длины [math]z[i][/math] строки [math]s[/math]. Но если при посимвольном записывании этого префикса в конец строки [math]s[/math] мы нашли такой [math]j[/math] (индекс последнего символа строки), что [math]z[j][/math] больше, чем длина оставшейся незаписанной части префикса, то мы перестаём писать этот префикс и пишем префикс длиной [math]z[j][/math] строки [math]s[/math].

Для правильной работы алгоритма, будем считать значение [math]z[0][/math] равным нулю.

Алгоритм всегда сможет построить строку по корректному массиву значений Z-функции, если в алфавите больше одного символа.

Если строить строку по некорректному массиву значений Z-функции, то мы получим какую-то строку, но массив значений Z-функций от неё будет отличаться от исходного.

Реализация

string buildFromZ(z : int[], alphabet : char[]):
  string s = ""
  int prefixLength = 0 // длина префикса, который мы записываем
  int j // позиция символа в строке, который будем записывать
  int newCharacter = 0 // индекс нового символа
  for i = 0 to z.length - 1
      // мы не пишем какой-то префикс и не будем писать новый
      if z[i] = 0 and prefixLength = 0
          if newCharacter < alphabet.length
              s += alphabet[newCharacter]
              newCharacter++
          else
              s += alphabet[newCharacter - 1]
      // нам нужно запомнить, что мы пишем префикс 
      if z[i] > prefixLength
          prefixLength = z[i]
          j = 0
      // пишем префикс
      if prefixLength > 0
          s += s[j]
          j++
          prefixLength--       
  return s

Доказательство корректности алгоритма

Докажем, что если нам дали корректную Z-функцию, то наш алгоритм построит строку с такой же Z-функцией.

Пусть [math]z[/math] — данная Z-функция, строку [math]s[/math] построил наш алгоритм, [math]q[/math] — массив значений Z-функции для [math]s[/math]. Покажем, что массивы [math]q[/math] и [math]z[/math] будут совпадать.

Так как значение в [math]z[0][/math] неопределено, то мы рассматриваем ненулевые индексы массива [math]z[/math].

Если [math]z[i] = 0[/math], то по алгоритму [math]s[i][/math] будет отличаться от [math]s[0][/math]. Тогда, при подсчёте Z-функции для полученной строки, мы получим, что [math]q[i] = 0[/math], ведь [math]s[i] \neq s[0][/math]. Значит, если [math]z[i] = 0[/math], то [math]z[i] = q[i][/math].

Рассмотрим значения [math]z[i] \ne 0[/math]. В этом случае [math]s[i][/math] является началом префикса исходной строки. Будем называть подстроки, совпадающие с префиксом строки, блоками. Возможны три случая:

  • Мы полностью записали рассматриваемый блок длиной [math]z[i][/math]. По определению Z-функции [math]q[i] = z[i][/math].
  • Мы записали часть рассматриваемого блока [math]b_1[/math] и прервались, чтобы записать новый блок [math]b_2[/math]. Допустим, что мы полностью написали блок [math]b_1[/math], а после написали блок [math]b_2[/math]. В таком случае мы переписали символы в пересечении двух блоков. Эти символы совпадают, иначе массив [math]z[/math] был бы некорректным. Поэтому блок [math]b_1[/math] запишется правильно и полностью. Этот случай мы уже рассмотрели выше.
  • Рассматриваемый блок [math]b_1[/math] полностью покрывается блоком [math]b_2[/math], который мы уже пишем. Допустим, что мы напишем блок [math]b_1[/math] после того, как написали блок [math]b_2[/math]. При корректном массиве [math]z[/math] символы в пересечении двух блоков совпадут. Тогда мы можем просто рассматривать блок [math]b_1[/math] аналогично одному из предыдущих случаев.

Таким образом, мы доказали, что значения массивов [math]q[/math] и [math]z[/math] совпадают.

Построение Z-функции по префикс-функции

Случай первый
Случай второй
Случай третий

Постановка задачи

Дан массив с корректной префикс-функцией для строки [math]s[/math], получить массив с Z-функцией для строки [math]s[/math].

Описание алгоритма


Пусть префикс функция хранится в массиве [math]P[0 ... n - 1][/math]. Z-функцию будем записывать в массив [math]Z[0 ... n-1][/math]. Заметим, что если [math]P[i]\gt 0[/math], то мы можем заявить, что [math]Z[i-P[i]+1][/math] будет не меньше, чем [math]P[i][/math].

Так же заметим, что после такого прохода в [math]Z[1][/math] будет максимальное возможное значение. Далее будем поддерживать инвариант: в [math]Z[i][/math] будет максимальное возможное значение.

Пусть в [math]Z[i] = z \gt 0[/math], рассмотрю [math]j\lt z[/math], [math]Z[j]=k[/math] и [math]Z[i+j]=k_1[/math]. Заметим, что [math]s[0 ... z-1][/math] совпадает с [math]s[i...i+z-1][/math] и тогда возможны три случая:

  1. [math]k\lt k_1[/math].
    Тогда очевидно, что мы не можем увеличить значение [math]Z[i+j][/math] и надо рассматривать уже [math]i=i+j[/math].
  2. [math]k\lt z-j[/math] и [math]k\gt k_1[/math].
    Тогда очевидно, что [math]Z[i+j][/math] можно увеличить до [math]k[/math].
  3. [math]k\gt z-j[/math] и [math]k\gt k_1[/math].
    Тогда понятно, что [math]Z[i+j]=z-j[/math].







Псевдокод

int[] buildZFunctionFromPrefixFunction(P : int[])
  int[] Z = int[n]
  for i = 1 to n - 1
     if P[i] > 0
        Z[i - P[i] + 1] = P[i]
  Z[0] = n
  int t
  for i = 1 to n - 1
     t = i
     if Z[i] > 0
        for j = 1 to Z[i] - 1
           if Z[i+j] > Z[j]
              break
           Z[i + j] = min(Z[j], Z[i] - j)
           t = i + j
     i = t
  return Z

См. также

Источники информации