Z-функция

Определение:

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].

Время работы

Этот алгоритм работает за [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], получить за [math]O(n)[/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(int[] P)
  int n = P.length;
  int[] Z = new int[n]
  for(int i = 1; i < n; i++)
     if(P[i])
        Z[i - P[i] + 1] = P[i]
  Z[0] = n;
  int t
  for(int i = 1; i < n - 1; i++)
     t = i;
     if(Z[i])
        for(int j = 1; j < Z[i] && Z[i + j] <= Z[j]; j++)
           Z[i + j] = min(Z[j], Z[i] - j)
           t = i + j
     i = t
  return Z

См. также

• Префикс-функция
• Алгоритм Кнута-Морриса-Пратта

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

• Поиск подстроки и смежные вопросы — Хабр
  
• Википедия — Z-функция
  
• Переход между Z- и префикс- функциями