1 问题
请实现一个函数用来匹配包括’.‘和’*'的正则表达式。
- 模式中的字符’.'表示任意一个字符
- 模式中的字符’'表示它前面的字符可以出现任意次(包含0次)。
在本题中,匹配是指字符串的所有字符匹配整个模式。例如,字符串"aaa"与模式"a.a"和"abaca"匹配,但是与"aa.a"和"aba"均不匹配
数据范围:
- str 只包含从 a-z 的小写字母。
- pattern 只包含从 a-z 的小写字母以及字符 . 和 ,无连续的 ''。
- 0 ≤ 0 \leq 0≤ str.length ≤ 26 \leq 26 ≤26
- 0 ≤ 0 \leq 0≤ pattern.length ≤ 26 \leq 26 ≤26
示例1
输入:“aaa”,"aa"
返回值:true
说明:中间的可以出现任意次的a,所以可以出现1次a,能匹配上
示例2
输入:“aad”,“cad”
返回值:true
说明:因为这里 c 为 0 个,a被重复一次, * 表示零个或多个a。因此可以匹配字符串 “aad”。
示例3
输入:“a”,“."
返回值:true
说明:".” 表示可匹配零个或多个(‘*’)任意字符(‘.’)
示例4
输入:“aaab”,“aaa*c”
返回值:false
2 答案
自己写的不对,递归算法
class Solution:
def match(self, str: str, pattern: str) -> bool:
return self.dfs(str, pattern, 0, 0)
def dfs(self, str, pattern, i, j):
if i == len(str) - 1 and j == len(pattern) - 1:
return True
if i > len(str) - 1 or j > len(pattern) - 1:
return False
if str[i] == pattern[j] or pattern[j] == '.':
return self.dfs(str, pattern, i+1, j+1)
if str[i] != pattern[j]:
if pattern[j] == '*' and str[i] == pattern[j-1]:
return self.dfs(str, pattern, i+1, j)
if pattern[j+1] == '*':
return self.dfs(str, pattern, i, j+1)
return False
官方解
- 递归
什么问题可以用递归解决?
- 主问题可以拆分为多个子问题;
- 主问题和子问题的解题思路一致;
- 存在终止条件。
递归问题如何解决?
- 找到递推公式;
- 找到终止条件;
- 将他们翻译成代码。
class Solution:
def match(self , str , pattern ):
if not pattern: #1.特殊情况,不存在匹配模式,那么就没有匹配字符串
return not str
#2. 递归的终止条件f(1) = 1:在这里就是 首位即匹配。
first_match = str and pattern[0] in {str[0], '.'}
#如果模式长度 >= 2,并且 模式索引[1] == '*'情况,也要分两种:
if len(pattern) >= 2 and pattern[1] == '*':
#第一种就是模式长度>2的情况下:字符串完全匹配从模式索引2之后的位置
return (self.match(str, pattern[2:]) or
#或者模式长度 =2的情况下:字符串从索引1位置开始,完全匹配模式
first_match and self.match(str[1:], pattern))
else:
#否则,模式长度>=2,而模式索引从1开始是 点字符或 *字符在其他位置,
return first_match and self.match(str[1:], pattern[1:])
- 动态规划,不大好理解,特别是两种子问题的情况
class Solution:
def match(self, str, pattern):
m, n = len(str), len(pattern) # 分别找到str和pattern的长度
def matches(i, j): # 定义一个转移方程函数
if i == 0: # 首先考虑一种特殊情况: str为空;
# 否则第一种是当i、j指向的字符是同一个字母/点号(".")的时候,我们只需要判断对应位置的字符是否相同,
# 相同则转移状态去判断子问题f[i-1][j-1]是否匹配
return False
if pattern[j - 1] == ".":
return True
return str[i - 1] == pattern[j - 1] # 其实就是对比当前位,而不是前一位
f = [[False] * (n + 1) for _ in range(m + 1)]
f[0][0] = True # 动态规划的边界条件为f[0][0]=true,即两个空字符串是可以匹配的
for i in range(m + 1):
for j in range(1, n + 1):
# 判断当j 指向 * 号的时候两种情况:
if pattern[j - 1] == "*":
f[i][j] |= f[i][j - 2]
if matches(i, j - 1):
f[i][j] |= f[i - 1][j]
else:
if matches(i, j):
f[i][j] |= f[i - 1][j - 1]
return f[m][n]
示例
https://www.nowcoder.com/share/jump/9318638301698459801907