【剑指offer】JZ19 正则表达式匹配

1 问题

请实现一个函数用来匹配包括’.‘和’*'的正则表达式。

1. 模式中的字符’.'表示任意一个字符
2. 模式中的字符’'表示它前面的字符可以出现任意次（包含0次）。
   在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"aba"均不匹配

数据范围:

1. str 只包含从 a-z 的小写字母。
2. pattern 只包含从 a-z 的小写字母以及字符 . 和 ，无连续的 ''。
3. $0\le$ str.length $\le 26$
4. $0\le$ pattern.length $\le 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

官方解

1. 递归

什么问题可以用递归解决？

• 主问题可以拆分为多个子问题；
• 主问题和子问题的解题思路一致；
• 存在终止条件。

递归问题如何解决？

• 找到递推公式；
• 找到终止条件；
• 将他们翻译成代码。

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:])

2. 动态规划，不大好理解，特别是两种子问题的情况

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