1. Название
Дайте вам строку s и правило символов p, пожалуйста, реализуйте сопоставление регулярных выражений, которое поддерживает '.' И '*'.
'.' соответствует любому одиночному символу
'*' соответствует нулю или более из предыдущего элемента.
Так называемое совпадение должно охватывать всю строку s, а не часть строки.
Описание:
s может быть пустым и содержать только строчные буквы от az.
p может быть пустым и содержать только строчные буквы от az, а также символы. и *.
Пример 1:
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
Пример 2:
输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此,字符串 "aa" 可被视为 'a' 重复了一次。
Пример 3:
输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个('*')任意字符('.')。
Пример 4:
输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个,这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
Пример 5:
输入:
s = "mississippi"
p = "mis*is*p*."
输出: false
Два, решить
1. Рекурсия
Идеи:
См. Ссылку 2 для получения подробной информации, а затем изучите ее вместе с комментариями.
Код:
// V1.0
class Solution {
public boolean isMatch(String s, String p) {
// Terminator
if(p.isEmpty()) return s.isEmpty();
// 不涉及 "*" ,单元素匹配
boolean match = !s.isEmpty() && ((s.charAt(0) == p.charAt(0)) || p.charAt(0) == '.');
// 涉及 ”*“ ,多元素匹配。* 的作用是 消除前面字符p[j-1],或者复制>=1个字符p[j-1]
if(p.length() >= 2 && p.charAt(1) == '*') return isMatch(s, p.substring(2)) || (match && isMatch(s.substring(1), p));
return match && isMatch(s.substring(1), p.substring(1));
}
}
// V2.0:优化charAt(i),加速
class Solution {
public boolean isMatchChar(char[] s, int s1, char[] p, int p1) {
if(p1 >= p.length) return s1 >= s.length;
boolean match = s1 < s.length && ((s[s1] == p[p1]) || p[p1] == '.');
if(p.length - p1 >= 2 && p[p1 + 1] == '*') return isMatchChar(s, s1, p, p1 + 2) || (match && isMatchChar(s, s1 + 1, p, p1));
return match && isMatchChar(s, s1 + 1, p, p1 + 1);
}
public boolean isMatch(String s, String p) {
char[] ss = s.toCharArray(), pp = p.toCharArray();
return isMatchChar(ss, 0, pp, 0);
}
}
Временная сложность: O ((m + n) ∗ 2 m + 2 n) O ((m + n) ∗ 2 ^ {m + 2n})O ( ( м+п ) * 2м + 2 п )
Сложность пространства: O ((m + n) ∗ 2 m + 2 n) O ((m + n) ∗ 2 ^ {m + 2n})O ( ( м+п ) * 2м + 2 п )
2. Мемоизация + рекурсия
Идея: То же, что и выше.
Код:
class Solution {
int[][] mem;
public boolean isMatchChar(char[] s, int s1, char[] p, int p1) {
if(p1 >= p.length) return s1 >= s.length;
if(mem[s1][p1] != 0) return mem[s1][p1] > 0;
boolean match = s1 < s.length && ((s[s1] == p[p1]) || p[p1] == '.');
if(p.length - p1 >= 2 && p[p1 + 1] == '*') {
boolean t = isMatchChar(s, s1, p, p1 + 2) || (match && isMatchChar(s, s1 + 1, p, p1));
if(t) mem[s1][p1] = 1;
else mem[s1][p1] = -1;
return t;
}
boolean t = match && isMatchChar(s, s1 + 1, p, p1 + 1);
if(t) mem[s1][p1] = 1;
else mem[s1][p1] = -1;
return t;
}
public boolean isMatch(String s, String p) {
this.mem = new int[s.length() + 1][p.length() + 1];
char[] ss = s.toCharArray(), pp = p.toCharArray();
return isMatchChar(ss, 0, pp, 0);
}
}
Временная сложность: O (mn) O (mn)O ( m n )
сложность пространства: O (mn) O (mn)О ( м п )
3. Динамическое планирование
Идеи:
1、状态定义
dp[i][j]:表示 S 的前 i 个能否被 P 的前 j 个字符匹配。
2、转移方程
dp[i-1][j-1]: 前面字串匹配成功,即 S 的前 i-1 个字符成功匹配上 P 的前 j-1 个字符。
So
1. If p.charAt(j) == s.charAt(i) : dp[i][j] = dp[i-1][j-1];
// dp[i-1][j-1]: 前面字串匹配成功,后面也匹配上,全部匹配成功。
2. If p.charAt(j) == '.' : dp[i][j] = dp[i-1][j-1];
// 前面字串匹配成功,现在 j 位置的 "." 可成功匹配 s i 位置的任意一个字符,所以 dp[i][j] = dp[i-1][j-1].
3. If p.charAt(j) == '*':
// 有以下几种可能:
--1:if p.charAt(j-1) != s.charAt(i) : dp[i][j] = dp[i][j-2]
// * 代表 0 个字符,消除p 的 j-1 个字符,这种情况说明 p 的最后两个字符无效,可去除。即dp[i][j]的状态依赖于dp[i][j-2]。
--2:if p.charAt(j-1) == s.charAt(i) or p.charAt(i-1) == '.':
dp[i][j] = dp[i-1][j]
// * 代表多个字符,这里正向去理解,如果 代表多个,则 s 后面再添一个也不影响。
// 例如: ## 与 ##b* 一旦匹配,则##b 与 ##b* 也匹配成功。
or dp[i][j] = dp[i][j-1]
// * 代表 1 个字符,即 * 可以理解为不起作用,所以dp[i][j]=dp[i][j-1]
or dp[i][j] = dp[i][j-2]
// * 代表 0 个字符,消除p 的 j-1 个字符,这种情况说明 p 的最后两个字符无效,可去除。即dp[i][j]的状态依赖于dp[i][j-2]。
==>进一步整理如下:
1. p[j−1] 为 普通字符,若s[i-1]==p[j-1],则 dp[i][j] = dp[i-1][j-1],否则匹配失败。
2. p[j−1] 为 '.',则 dp[i][j] = dp[i−1][j−1]
3. p[j−1] 为 '*' :
(1)不看,则 dp[i][j] = dp[i][j-2]
(2)看, 则 dp[i][j] = dp[i-1][j]
Код:
public class Solution {
public boolean isMatch(String s, String p) {
char[] str = s.toCharArray(), ptr = p.toCharArray();
boolean[][] dp = new boolean[str.length + 1][ptr.length + 1];
dp[0][0] = true;
for (int i = 0; i <= str.length; i++) {
for (int j = 1; j <= ptr.length; j++) {
if(ptr[j - 1] != '*') {
if(i > 0 && (str[i - 1] == ptr[j - 1] || ptr[j - 1] == '.')) dp[i][j] = dp[i - 1][j - 1];
}else {
//ptr[j - 1] == '*'
if(j > 1) dp[i][j] |= dp[i][j - 2]; //不看
if(i > 0 && j > 1 && (str[i - 1] == ptr[j - 2] || ptr[j - 2] == '.'))dp[i][j] |= dp[i - 1][j]; //看
}
}
}
return dp[str.length][ptr.length];
}
}
Временная сложность: O (mn) O (mn)O ( m n )
сложность пространства: O (mn) O (mn)О ( м п )
4. Конечный автомат
Идеи: просто делитесь идеями, подробнее см. Ссылку 3.
Код: опущен.
Временная сложность: незначительно.
Космическая сложность: незначительно.
Три, ссылка
1. Динамическое программирование - объяснение с 0, простое для понимания на просторечии
2. Рекурсивная пошаговая оптимизация Java, чтобы превзойти 100%, и динамическое планирование, ясное мышление
3. Сопоставление регулярных выражений
4. Сопоставление регулярных выражений
5. 10. Регулярное выражение Соответствие