1. Título
Déle una cadena sy una regla de carácter p, por favor implemente una coincidencia de expresión regular que admita '.' Y '*'.
"." coincide con cualquier carácter
"*" coincide con cero o más del elemento anterior. La
llamada coincidencia es para cubrir la cadena completa s, no parte de la cadena.
Descripción:
s puede estar vacío y solo contener letras minúsculas de az.
p puede estar vacío y solo contiene letras minúsculas de az y los caracteres. y *.
Ejemplo 1:
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
Ejemplo 2:
输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
Ejemplo 3:
输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
Ejemplo 4:
输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
Ejemplo 5:
输入:
s = "mississippi"
p = "mis*is*p*."
输出: false
Dos, resolver
1. Recurrencia
Ideas:
Consulte la referencia 2 para obtener más detalles, y luego comprenda junto con los comentarios.
Código:
// 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);
}
}
Complejidad de tiempo: O ((m + n) ∗ 2 m + 2 n) O ((m + n) ∗ 2 ^ {m + 2n})O ( ( m+n ) ∗ 2m + 2 n )
Complejidad del espacio: O ((m + n) ∗ 2 m + 2 n) O ((m + n) ∗ 2 ^ {m + 2n})O ( ( m+n ) ∗ 2m + 2 n )
2. Memorización + recursividad
Idea: Igual que arriba.
Código:
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);
}
}
Complejidad de tiempo: O (mn) O (mn)O ( m n )
el espacio complejidad: O (mn) O (mn)O ( m n )
3. Planificación dinámica
Ideas:
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]
Código:
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];
}
}
Complejidad de tiempo: O (mn) O (mn)O ( m n )
el espacio complejidad: O (mn) O (mn)O ( m n )
4. Máquina de estados finitos
Ideas: simplemente abra ideas, consulte la referencia 3 para obtener más detalles.
Código: Omitido.
Complejidad temporal: levemente.
Complejidad espacial: levemente.
Tres, referencia
1. Programación dinámica: explicada desde 0, fácil de entender en la lengua vernácula
2. Optimización paso a paso recursiva de Java para superar el 100% y planificación dinámica, pensamiento claro
3. Coincidencia de expresiones regulares
4. Coincidencia de expresiones regulares
5. 10. Expresión regular Pareo