В этой статье я разберу решение задачи сопоставления строки шаблону с регулярным выражением, которая предлагается сайтом LeetCode под номером 10.

Постановка.

Даны строка и шаблон , реализующий регулярное выражение с поддержкой специальных символов $\text{"."}$ и $\text{"*"}$ , где:

$\text{"."}$ сопоставляется с любым символом входящей строки,
$\text{"*"}$ совместно с предыдущим символом шаблона сопоставляется с подстрокой из нуля или более таких же символов во входящей строке.

Необходимо ответить на вопрос, соответствует ли представленная строка шаблону или нет. При этом соответствие должно охватывать всю входную строку, а не только её часть.

Пример 1

Вход: $S=\text{"aa"}$ , $P=\text{"a"}$
Выход:
Объяснение: шаблон $\text{"a"}$ не совпадает со всей строкой $\text{"aa"}$ .

Пример 2

Вход: $S=\text{"aa"}$ , $P=\text{"a*"}$
Выход:
Объяснение: $\text{"*"}$ означает ноль или более предшествующих элементов $\text{"a"}$ , таким образом, при повторении $\text{"a"}$ , получается $\text{"aa"}$ .

Пример 3

Вход: $S=\text{"ab"}$ , $P=\text{".*"}$
Выход:
Объяснение: $\text{".*"}$ означает последовательность из нуля или более любых символов.

Ограничения:

$1\le \left| S \right|\le 20$
$1\le \left| P \right|\le 20$
содержит только буквы латинского алфавита в нижнем регистре.
содержит только буквы латинского алфавита в нижнем регистре.
гарантируется, что для каждого символа $\text{"*"}$ в шаблоне всегда присутствует предыдущий символ, совместно с которым $\text{"*"}$ используется.

Метод

Существует несколько методик проверки соответствия строки регулярному выражению. Традиционно эта задача решается с помощью недетерминированного конечного автомата (Nondeterministic Finite Automaton, NFA), в который компилируется регулярное выражение. Автомат читает строку символов и использует её как инструкцию для изменения своего состояния, чтобы в конце концов ответить на вопрос, соответствует ли входящая строка исходному шаблону или нет. Однако, LeetCode любезно подсказывает нам, что в данном случае лучше применить динамическое программирование. Воспользуемся этим советом. Введем функцию соответствия , которая принимает на вход строку и шаблон , а возвращает либо , если строка соответствует шаблону, либо в противном случае. Нам необходимо придумать реализацию этой функции. Для этого мы проанализируем, как должна работать функция соответствия на примере нескольких частных случаев, и воспользуемся «реверсивным инжинирингом», чтобы попытаться воссоздать её реализацию.

Рекурсия

Пусть $S=\text{"abc"}$ и $P=\text{"abc"}$ . При использовании динамического программирования первое, что необходимо сделать, это разбить исходную задачу на более мелкие подзадачи. Пусть ${{S}_{i}}$ — строка, состоящая из первых символов строки , ${{P}_{j}}$ - шаблон, состоящий из первых символов шаблона , а ${{F}_{i,j}}$ — результат сопоставления строки ${{S}_{i}}$ шаблону ${{P}_{j}}$ . Тогда получим такие значения ${{S}_{i}}$ и ${{P}_{j}}$ :

Вычислим значения функции ${{F}_{i,j}}=F({{S}_{i}},{{P}_{j}})$ для каждой ячейки представленной таблицы. Поскольку пустая строка и пустой шаблон эквивалентны, следовательно

${{F}_{0,0}}=F({{S}_{0}},{{P}_{0}})=F(\text{""},\text{""})=true$ .

Очевидно, любая непустая строка не сопоставима с пустым шаблоном, как и любой непустой шаблон без специальных символов не сопоставим с пустой строкой, следовательно:

${{F}_{i,0}}=F({{S}_{i}},{{P}_{0}})=F({{S}_{i}},\text{""})=false$
${{F}_{0,j}}=F({{S}_{0}},{{P}_{j}})=F(\text{""},{{P}_{j}})=false$

В итоге получаем следующую таблицу:

В нашем примере шаблон не использует специальные символы, поэтому соответствие строки шаблону определяется простым отношением эквивалентности.

Теперь попробуем выразить решение ${{F}_{i,j}}$ через решения более мелких подзадач ${F_{l,k}}$ , таких, что $l \le i$ и $k \le j$ . Заметьте, что ${F_{3,3}} = true$ , так как выполняется два условия: во-первых, последний символ строки ${S_3}$ эквивалентен последнему символу шаблона ${P_3}$ , и, во-вторых, подстрока строки ${S_3}$ без её последнего символа соответствует шаблону ${P_3}$ без его последнего символа.

${F_{3,3}} = F({S_3},{P_3}) =$
$= F(\text{"abc"},\text{"abc"}) =$
$= F(\text{"ab"},\text{"ab"}) \wedge (\text{"c"} \equiv \text{"c"}) =$
$= F({S_2},{P_2}) \wedge ({s_3} \equiv {p_3}) =$
$= {F_{2,2}} \wedge ({s_3} \equiv {p_3})$

Пусть ${s_i}$ — это последний символ строки ${S_i}$ , а ${p_j}$ — это последний символ шаблона ${P_j}$ , тогда обобщив полученную выше формулу для всей таблицы, получим:

${F_{0,0}} = true$
${F_{i,0}} = false$
${F_{0,j}} = false$
${F_{i,j}} = {F_{i - 1,j - 1}} \wedge ({s_i} \equiv {p_j})$

Таким образом, чтобы вычислить значение ${F_{3,3}}$ необходимо знать значение ${F_{2,2}}$ , чтобы вычислить значение ${F_{2,2}}$ , необходимо знать значение ${F_{1,1}}$ , а значение ${F_{0,0}}$ , необходимое для вычисления ${F_{1,1}}$ уже известно: ${F_{0,0}} = true$ , это базовый случай для рекурсии, которую мы вывели.

Универсальный символ.

В предыдущей части мы рассмотрели тривиальный случай, когда в шаблоне не было никаких специальных символов. Теперь попробуем сопоставить строку $S = \text{"abc"}$ с шаблоном $P = \text{"a.c"}$ . В шаблоне появился символ "точка", соответствующий любому символу строки . Его также называют подстановочным или универсальным символом. Разобьём строку и шаблон на подзадачи и заполним таблицу соответствия по аналогии с предыдущим примером.

Как видите, в таблице практически ничего не изменилось. Хотя в шаблоне теперь вместо символа $\text{"b"}$ стоит символ $\text{"."}$ , но на результат проверки соответствия это никак не повлияло, ведь универсальный символ шаблона можно сопоставить с любым символом строки , в том числе с символом $\text{"b"}$ . В предыдущей части мы вывели рекурсивную формулу для вычисления функции соответствия: ${F_{i,j}} = {F_{i - 1,j - 1}} \wedge ({s_i} \equiv {p_j})$ . Введем функцию соответствия последнего символа строки последнему символу шаблона: $M({S_i},{P_j}) = ({s_i} \equiv {p_j}) \vee ({p_j} \equiv \text{"."}) = {M_{i,j}}$ , то есть ${M_{i,j}}$ имеет значение тогда и только тогда, когда либо последний символ строки ${S_i}$ эквивалентен последнему символу шаблона ${P_j}$ : ${s_i} \equiv {p_j}$ , где ${s_i}$ - последний символ строки ${S_i}$ , а ${p_j}$ - последний символ шаблона ${P_j}$ , либо последний символ шаблона ${P_j}$ является универсальным символом, то есть ${p_j} \equiv \text{"."}$ . Тогда рекурсивная формула соответствия примет следующий вид:

${F_{0,0}} = true$
${F_{i,0}} = false$
${F_{0,j}} = false$
${F_{i,j}} = {F_{i - 1,j - 1}} \wedge {M_{i,j}}$
${M_{i,j}} = ({s_i} \equiv {p_j}) \vee ({p_j} \equiv \text{"."})$

Звезда Клини.

По условию задачи в регулярном выражении может присутствовать символ «звездочка», также известный как звезда Клини. Он играет роль итератора для предыдущего символа шаблона. Если после какого-либо символа шаблона следует звезда Клини, то этой паре, символ и звезда, можно поставить в соответствие строку длины ноль или более из таких же символов. Например, шаблон $\text{"a*"}$ соответствует строке $\text{"aaa"}$ , строке $\text{"aa"}$ , строке $\text{"a"}$ и даже пустой строке $\text{""}$ .

Cопоставим строку $S = \text{"abb"}$ с шаблоном $P = \text{"ab*"}$ . Функция сопоставления строк с шаблонами без звезды Клини вычисляется также как и в предыдущих примерах.

${F_{0,0}} = true$
${F_{i,0}} = false$
${F_{0,j}} = false$
${F_{i,j}} = {F_{i - 1,j - 1}} \wedge {M_{i,j}}$
${M_{i,j}} = ({s_i} \equiv {p_j}) \vee ({p_j} \equiv \text{"."})$

Изменения появляются при сопоставлении строк с шаблоном ${P_3} = \text{"ab*"}$ :

Почему строка $\text{"a"}$ соответствует шаблону $\text{"ab*"}$ ? Причина в звезде Клини. Шаблону $\text{"b*"}$ можно поставить в соответствие строку, состоящую из символов $\text{"b"}$ любой длины в том числе и нулевой. Это значит, мы можем сопоставить выражение $\text{"b*"}$ с пустой подстрокой в строке $\text{"a"}$ . Представим строку $\text{"a"}$ как конкатенацию строки $\text{"a"}$ и пустой строки: $\text{"a"}||\text{""}$ . Шаблон $\text{"ab*"}$ соответствует этой конкатенации тогда и только тогда, когда пустая строка сопоставляется с последними двумя символами этого шаблона, то есть $\text{"b*"}$ , а оставшаяся часть строки соответствует оставшейся части шаблона.

${F_{1,3}} = F({S_1},{P_3}) =$
$= F(\text{"a"},\text{"ab*"}) =$
$= F(\text{"a"},\text{"a"}) \wedge F(\text{""},\text{"b*"}) =$
$= F({S_1},{P_1}) =$
$= {F_{1,1}}$

Почему строка $\text{"abb"}$ соответствует шаблону $\text{"ab*"}$ ? Причина снова в звезде Клини. Однако, на этот раз шаблон $\text{"b*"}$ сопоставляется не с пустой строкой, а со строкой $\text{"bb"}$ . Чтобы сопоставление строки $\text{"abb"}$ с шаблоном $\text{"ab*"}$ было успешным, необходимо выполнение двух условий. Во-первых, последний символ строки должен соответствовать предпоследнему символу шаблона, тому символу, который итерируется звездой Клини. И, во-вторых, оставшаяся часть строки, без последнего символа, тоже должна соответствовать текущему шаблону. Заметьте, на этот раз мы не удаляем из шаблона $\text{"ab*"}$ последние два символа $\text{"b*"}$ , они нам ещё понадобятся для вычисления функции соответствия на шаге ${F_{2,3}} = F(\text{"ab"},\text{"ab*"})$ . Также, обратите внимание, что последний символ строки не обязан быть эквивалентным предпоследнему символу шаблона, он должен соответствовать ему. В шаблоне может быть универсальный символ, кодируемый «точкой». Поэтому последний символ строки соответствует предпоследнему символу шаблона тогда и только тогда, когда выполняется хотя бы одно условие: либо эти символы эквивалентны друг другу, либо символ шаблона является универсальным символом.

${F_{3,3}} = F({S_3},{P_3}) =$
$= F(\text{"abb"},\text{"ab*"}) =$
$= F(\text{"ab"},\text{"ab*"}) \wedge ((\text{"b"} \equiv \text{"b"}) \vee (\text{"b"} \equiv \text{"."})) =$
$= F({S_2},{P_3}) \wedge (({s_3} \equiv {p_2}) \vee ({p_2} \equiv \text{"."})) =$
$= {F_{2,3}} \wedge {M_{3,2}}$

${F_{2,3}} = F({S_2},{P_3}) =$
$= F(\text{"ab"},\text{"ab*"}) =$
$= F(\text{"a"},\text{"ab*"}) \wedge ((\text{"b"} \equiv \text{"b"}) \vee (\text{"b"} \equiv \text{"."})) =$
$= F({S_1},{P_3}) \wedge (({s_2} \equiv {p_2}) \vee ({p_2} \equiv \text{"."})) =$
$= {F_{1,3}} \wedge {M_{2,2}}$

Мы видим, что формулы ${F_{1,3}} = {F_{1,1}}$ и ${F_{3,3}} = {F_{2,3}} \wedge {M_{3,2}}$ различаются. В первом случае мы получили соответствие, когда полностью выкинули из шаблона выражение со звездой Клини. Во втором случае, последний символ строки оказался эквивалентен операнду звезды Клини (предпоследнему символу шаблона), что позволило выкинуть из строки этот последний символ и сопоставить шаблон с её оставшейся частью. Чтобы обобщить формулу соответствия используем дизъюнкцию (логическое ИЛИ) полученных выражений.

${F_{i,j}} = {F_{i,j - 2}} \vee ({F_{i - 1,j}} \wedge {M_{i,j - 1}})$

Объединив формулу для шаблонов без звезды Клини и формулу для шаблонов со звездой Клини, получим следующую реализацию функции соответствия:

${F_{0,0}} = true$
${F_{i,0}} = false$
${F_{i,j}} = {F_{i - 1,j - 1}} \wedge {M_{i,j}}$ , если ${p_j} \ne \text{"*"}$
${F_{i,j}} = {F_{i,j - 2}} \vee ({F_{i - 1,j}} \wedge {M_{i,j - 1}})$ , если ${p_j} = \text{"*"}$
${M_{i,j}} = ({s_i} \equiv {p_j}) \vee ({p_j} \equiv \text{"."})$

Заметьте, формула «потеряла» базовый случай ${F_{0,j}} = false$ , который мы применяли в примерах с шаблонами без звезды Клини. Действительно, появление этого специального символа означает, что пустая строка теперь может соответствовать не только пустому шаблону.

Рассмотрим сопоставление пустой строки ${S_0} = \text{""}$ с шаблоном $P = \text{".*.*"}$ . Разобьем шаблон на фрагменты ${P_0} = \text{""}$ , ${P_1} = \text{"."}$ , ${P_2} = \text{".*"}$ , ${P_3} = \text{".*."}$ и ${P_4} = \text{".*.*"}$ . Пустая строка соответствует пустому шаблону $F({S_0},{P_0}) = F(\text{""},\text{""}) =true$ . Однако, если шаблон указывает, что строка должна содержать хотя бы один символ, то соответствие нарушается $F({S_0},{P_1}) = F(\text{""},\text{"."}) = false$ . С другой стороны, звезда Клини в шаблоне ${P_2} = \text{".*"}$ говорит нам, что строка может содержать любое количество символов в том числе и ноль. Это значит, что пустая строка снова может быть сопоставлена с таким шаблоном $F({S_0},{P_2}) = F(\text{""},\text{".*"}) = true$ . Шаблоны ${P_3} = \text{".*."}$ и ${P_4} = \text{".*.*"}$ повторяют ситуацию:

${F_{0,3}} = F({S_0},{P_3}) = F(\text{""},\text{".*."}) = F(\text{""},\text{".*"}) \wedge F(\text{""},\text{"."}) = false$
${F_{0,4}} = F({S_0},{P_4}) = F(\text{""},\text{".*.*"}) = F(\text{""},\text{".*"}) \wedge F(\text{""},\text{".*"}) = F({S_0},{P_2}) = {F_{0,2}}$

Если шаблон заканчивается на звезду Клини, то работает формула ${F_{0,j}} = {F_{0,j - 2}}$ , а в противном случае применяется базовый случай ${F_{0,j}} = false$ .

В итоге получаем следующую формулу для вычисления функции соответствия:

${F_{0,0}} = true$
${F_{i,0}} = false$
${F_{0,j}} = false$ , если ${p_j} \ne \text{"*"}$
${F_{0,j}} = {F_{0,j - 2}}$ , если ${p_j} = \text{"*"}$
${F_{i,j}} = {F_{i - 1,j - 1}} \wedge {M_{i,j}}$ , если ${p_j} \ne \text{"*"}$
${F_{i,j}} = {F_{i,j - 2}} \vee ({F_{i - 1,j}} \wedge {M_{i,j - 1}})$ , если ${p_j} = \text{"*"}$
${M_{i,j}} = ({s_i} \equiv {p_j}) \vee ({p_j} \equiv \text{"."})$

Сложность

Мы разобрали три случая сопоставления строки шаблону :

$S=\text{"abc"}, P=\text{"abc"}$
$S=\text{"abc"}, P=\text{"a.c"}$
$S=\text{"abb"}, P=\text{"ab*"}$

В первых двух примерах функция соответствия была успешно вычислена по формуле ${F_{i,j}} = {F_{i - 1,j - 1}} \wedge {M_{i,j}}$ . В ней рекурсивный вызов функции происходит всего один раз. Следовательно количество операций, которые необходимо выполнить для проверки соответствия, пропорционален длине строки. Это означает линейную сложность , рекурсивного алгоритма проверки. Однако, добавление в шаблон звезды Клини, резко меняет ситуацию. Чтобы проверить соответствие шаблону, последним символом которого является звезда Клини, мы применили формулу ${F_{i,j}} = {F_{i,j - 2}} \vee ({F_{i - 1,j}} \wedge {M_{i,j - 1}})$ . В ней для вычисления значения ${F_{i,j}}$ в худшем случае придется выполнить два рекурсивных вызова функции соответствия: ${F_{i,j - 2}}$ и ${F_{i - 1,j}}$ . Это обстоятельство сразу поднимает сложность рекурсивного алгоритма до экспоненциальной $O({2^n})$ .

Динамическое программирование предлагает сохранять вычисленные значения ${F_{i,j}}$ и при необходимости использовать их для последующих расчетов. Это позволяет избежать повторных вычислений функции соответствия с одними и теми же аргументами. Такой прием называется мемоизацией. Например, на рисунке 10 при проверке соответствия строки $S = \text{"abbc"}$ шаблону $P = \text{"ab*c"}$ мы начинаем вычисления с вызова функции $F(\text{"abbc"},\text{"ab*c"}) = {F_{4,4}}$ , она рекурсивно вызывает функцию $F(\text{"abb"},\text{"ab*"}) = {F_{3,3}}$ , которая в зависимости от реализации может вызвать сначала функцию $F(\text{"abb"},\text{"a"}) = {F_{3,1}}$ и, получив , вызвать $F(\text{"ab"},\text{"ab*"}) = {F_{2,3}}$ , либо сразу вызвать $F(\text{"ab"},\text{"ab*"})$ , тогда рекурсивный вызов $F(\text{"abb"},\text{"a"})$ не потребуется, но в такой реализации ветвление произойдет при вызове $F(\text{"a"},\text{"ab*"}) = {F_{1,3}}$ . Сначала будет вызвана функция $F(\text{""},\text{"ab*"}) = {F_{0,3}}$ , она вернет , и нам придется выполнить вызов $F(\text{"a"},\text{"a"}) = {F_{1,1}}$ , который в свою очередь вызывает $F(\text{""},\text{""}) = {F_{0,0}}$ , останавливая рекурсию базовым случаем ${F_{0,0}} = true$ .

Применяя мемоизацию, каждый раз, когда мы получаем конкретное значение функции соответствия ${F_{i,j}} = true$ или ${F_{i,j}} = false$ , нам необходимо его запомнить. А каждый раз, когда мы вызываем функцию соответствия $F({S_i},{P_j})$ , нам необходимо сразу же вернуть её значение, если оно было рассчитано ранее. Это сводит сложность повторного вычисления к. Поскольку функция соответствия параметризирована двумя индексами, то для хранения вычисленных значений удобно использовать двумерный массив. Какой размерности он должен быть? Если строка содержит символов, а шаблон состоит из символов, то максимальное значение индекса равно , а максимальное значение индекса равно . Поскольку минимальное значение индексов и равно , то для хранения промежуточных результатов нам потребуется матрица размера $(n + 1) \cdot (m + 1)$ Это значит, что для вычисления функции соответствия с применением мемоизации мы должны выполнить $O((n + 1) \cdot (m + 1)) = O(n \cdot m + n + m + 1) = O(n \cdot m)$ операций.

Реализация

Мемоизацию можно использовать, когда глубина рекурсии не слишком велика. Если длина строки или шаблона окажется очень большой, это может привести к переполнению стека при рекурсивном вызове функции сопоставления. Что если вообще избавиться от рекурсивных вызовов? Вычислим сначала функцию соответствия для пустой строки и пустого шаблона. Затем добавим к пустой строке один символ и проверим соответствие строки из одного символа с пустым шаблоном. Добавим к строке следующий символ и проверим соответствие строки из двух символов с пустым шаблоном. И так далее вплоть до проверки соответствия исходной строки пустому шаблону. На самом деле, нам даже не придется ничего проверять. Сейчас мы просто рассмотрели базовый случай рекурсии в формуле функции соответствия:

${F_{0,0}} = true$
${F_{i,0}} = false$

Сохраним эти значения в массив размера $(n + 1) \cdot (m + 1)$ , где - длина строки, а — длина шаблона.

int n = string.length(), m = pattern.length(); boolean[][] dp = new boolean[n + 1][m + 1]; dp[0][0] = true; for (int i = 1; i <= n; i++) { dp[i][0] = false; }

Теперь вычислим значения функции соответствия для пустой строки и шаблона, состоящего только из первого символа исходного шаблона. Для этого нам необходимо воспользоваться второй частью базового случая рекурсии из формулы соответствия:

${F_{0,j}}=false$ , если ${p_j} \ne \text{"*"}$
${F_{0,j}} = {F_{0,j - 2}}$ , если ${p_j} = \text{"*"}$

и ограничением из постановки задачи:

гарантируется, что для каждого символа $\text{"*"}$ в шаблоне всегда присутствует предыдущий символ, совместно с которым $\text{"*"}$ используется.

Поскольку в шаблоне только один символ, он не может быть звездой Клини, значит

${F_{0,1}} = F({S_0},{P_1}) = false$

Однако, при вычислении функции соответствия для пустой строки и первых двух символов исходного шаблона, фокус с ограничением из постановки уже не сработает. Нам придется сравнить последний символ шаблона с символом звезды Клини. Создадим для этой операции специальный метод.

private boolean isKleeneStar(char c) { return c == '*'; }

Если проверка на звезду Клини успешна, то вместо того, чтобы рекурсивно вызвать функцию соответствия $F({S_0},{P_{j - 2}})$ , мы просто обратимся к значению этой функции, которое было получено на предыдущем шаге ${F_{0,j - 2}} = F({S_0},{P_{j - 2}})$

for (int j = 1; j <= m; j++) { char patternChar = pattern.charAt(j - 1); if (isKleeneStar(patternChar)) { dp[0][j] = dp[0][j - 2]; } else { dp[0][j] = false; } }

В итоге получим код, который вычисляет и запоминает значения функции сопоставления пустой строки со всеми вариантами шаблона: ${F_{0,j}} = F({S_0},{P_j})$ , и значения функции сопоставления всех вариантов строки с пустым шаблоном: ${F_{i,0}} = F({S_i},{P_0})$ .

int n = string.length(), m = pattern.length(); boolean[][] dp = new boolean[n + 1][m + 1]; dp[0][0] = true; for (int i = 1; i <= n; i++) { dp[i][0] = false; }

for (int j = 1; j <= m; j++) { char patternChar = pattern.charAt(j - 1); if (isKleeneStar(patternChar)) { dp[0][j] = dp[0][j - 2]; } else { dp[0][j] = false; } }

Теперь обратимся к спецификации языка Java, чтобы понять, что этот фрагмент кода, на самом деле, содержит довольно много лишних операций.

4.12.5. Initial Values of Variables
Every variable in a program must have a value before its value is used:
Each class variable, instance variable, or array component is initialized with a default value when it is created (§15.9, §15.10.2):
For type boolean, the default value is false.

Это значит, что при создании массива все его элементы уже имею значение false. Нет необходимости присваивать это значение повторно, достаточно изменить только те элементы массива, значение которых должно быть true.

int n = string.length(), m = pattern.length(); boolean[][] dp = new boolean[n + 1][m + 1]; dp[0][0] = true; for (int j = 2; j <= m; j++) { char patternChar = pattern.charAt(j - 1); if (isKleeneStar(patternChar)) { dp[0][j] = dp[0][j - 2]; } }

Когда решения базовых подзадач ${F_{0,j}} = F({S_0},{P_j})$ и ${F_{i,0}} = F({S_i},{P_0})$ уже известны, их нужно использовать для вычисления более крупных задач:

${F_{i,j}}={F_{i - 1,j - 1}} \wedge {M_{i,j}}$ , если ${{\rm{p}}_j} \ne \text{"*"}$
${F_{i,j}}={F_{i,j - 2}} \vee ({F_{i - 1,j}} \wedge {M_{i,j - 1}})$ , если ${{\rm{p}}_j} = \text{"*"}$
${M_{i,j}} = ({s_i} \equiv {p_j}) \vee ({p_j} \equiv \text{"."})$

Такой подход, когда мы начинаем с решения мелких подзадач, а затем используем их для решения крупных подзадач, постепенно поднимая их сложность, чтобы в конечном итоге решить главную задачу, называется восходящим, и также известен как табуляция. В английской литературе его называют bottom-up подходом, в противовес мемоизации, которая называется top-down или нисходящим, подходом, и отличается от восходящего тем, что мы сразу начинаем решать главную задачу и рекурсивно опускаемся к решению более мелких подзадач, результаты которых запоминаем, чтобы впоследствии не вычислять их повторно. Мемоизация и табуляция являются двумя способами реализации методики динамического программирования на практике.

Создадим метод, который вычисляет соответствие последнего символа строки последнему символу шаблона: ${M_{i,j}} = ({s_i} \equiv {p_j}) \vee ({p_j} \equiv \text{"."})$

private boolean isMatch(char sc, char pc) { return sc == pc || pc == '.'; }

Тогда код, который решает остальные задачи:

${F_{i,j}}={F_{i,j - 2}} \vee ({F_{i - 1,j}} \wedge {M_{i,j - 1}})$ , если ${{\rm{p}}_j} = \text{"*"}$
${F_{i,j}}={F_{i - 1,j - 1}} \wedge {M_{i,j}}$ , если ${{\rm{p}}_j} \ne \text{"*"}$

выглядит следующим образом:

for (int j = 1; j <= m; j++) {     for (int i = 1; i <= n; i++) {         char patternChar = pattern.charAt(j - 1);         if (isKleeneStar(patternChar)) {             dp[i][j] = dp[i][j - 2] || (dp[i - 1][j]
&& isMatch(string.charAt(i - 1), pattern.charAt(j - 2)));         } else {             dp[i][j] = dp[i - 1][j - 1]
&& isMatch(string.charAt(i - 1), patternChar);         }     } }

Как вы могли заметить, индексация при получении последнего символа строки и шаблона смещена на единицу в меньшую сторону:

${M_{i,j}} = isMatch(string.charAt(i - 1),pattern.charAt(j - 1))$
${M_{i,j - 1}} = isMatch(string.charAt(i - 1),pattern.charAt(j - 2))$

Это связано с тем, что в Java адресация символов строки начинается с нуля, а в нашей формуле нулевой индекс строки или шаблона означает отсутствие в них каких-либо символов.

В итоге получим окончательную реализацию функции сопоставления:

public class Solution {

    public boolean isMatch(String string, String pattern) {
        int n = string.length(), m = pattern.length();
        boolean[][] dp = new boolean[n + 1][m + 1];
        dp[0][0] = true;
        for (int j = 2; j <= m; j++) {
            char patternChar = pattern.charAt(j - 1);
            if (isKleeneStar(patternChar)) {
                dp[0][j] = dp[0][j - 2];
            }
        }
        for (int j = 1; j <= m; j++) {
            for (int i = 1; i <= n; i++) {
                char patternChar = pattern.charAt(j - 1);
                if (isKleeneStar(patternChar)) {
                    dp[i][j] = dp[i][j - 2] || (dp[i - 1][j] 
                       && isMatch(string.charAt(i - 1), pattern.charAt(j - 2)));
                } else {
                    dp[i][j] = dp[i - 1][j - 1]
                       && isMatch(string.charAt(i - 1), patternChar);
                }
            }
        }
        return dp[n][m];
    }

    private boolean isKleeneStar(char c) {
        return c == '*';
    }

    private boolean isMatch(char sc, char pc) {
        return sc == pc || pc == '.';
    }
}

Заключение.

В этой статье мы разобрали, как проверить соответствие строки шаблону с регулярным выражением. Мы выяснили, что если бы в шаблоне не использовалась звезда Клини, то рекурсивный алгоритм проверки был бы очень простым и занимал линейное время, а звезда Клини сильно усложняет рекурсивную проверку, повышая её сложность до экспоненциальной. С помощью мемоизации нам удалось уменьшить сложность рекурсивного алгоритма до полиномиальной. Чтобы не допустить переполнения стека при выполнении рекурсивных вызовов, мы реализовали алгоритм проверки с помощью табуляции. Мы выяснили, что табуляция и мемоизация — это два способа имплементации парадигмы динамического программирования. В итоге, возможно, мы пришли к выводу, что решить подобную задачу на собеседовании, которое длится 60 минут, практически не реально.

Разбор задачи «Regular Expression Matching»