LeetCodeDifficult-【面试题19. 正则表达式匹配】

请实现一个函数用来匹配包含’. ‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。

示例 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 = “cab”
输出: true
解释: 因为 ‘*’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。

示例 5:

输入:
s = “mississippi”
p = “misisp*.”
输出: false
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

注意：本题与主站 10 题相同：https://leetcode-cn.com/problems/regular-expression-matching/
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zheng-ze-biao-da-shi-pi-pei-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路1：递规

这题的类别是Difficult级别的，初看确实有的不好考虑，特别是刚开始准备纯靠逻辑判断来做，发现后面情况太多，单纯判断不好做。于是看了题解，一堆用dp和递归来做了。但是dp的看了需求还是有的地方没太懂，于是自己用递归做出来了。想到用递归后思路其实很清晰，就是有的需要考虑的很全面才行。
具体的细节可以看代码。
个人认为dp其实就是递推，它其实就是和递归相反，它是从正面推算，而递归这较为简单，它是从后往前算。

• 第一份代码我假设了一个字符串中不会出现的字符#，加在需要判单字符串的开头，这样就避免判空的过程。
• 第二份代码具备了一般性

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        def match(s, p) ->bool:
            if s == p:
                return True
            if s == '' or p == '':
                return False
            if s[-1] == p[-1] or (p[-1] == '.' and s[-1] != '#'):
                return match(s[:-1], p[:-1])
            if p[-1] == '*':
                if len(p)>=2:
                    if p[-2] == s[-1] or (p[-2] == '.' and s[-1] != '#'):
                        # *匹配0个、一个或者多个
                        return match(s, p[:-2]) or match(s[:-1], p[:-2]) or match(s[:-1], p)
                    else:
                        # 不能匹配
                        return match(s, p[:-2])
            return False
        # 递归解法
        return match('#'+s, '#'+p)

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        def match(s, p) ->bool:
            if s == p:
                return True
            if s != '' and p == '':
                return False
            elif s == '' and p != '':
                if p[-1] == '*':
                    if len(p)>=2:
                        return match(s, p[:-2])
                return False
            else:
                if s[-1] == p[-1] or p[-1] == '.':
                    return match(s[:-1], p[:-1])
                if p[-1] == '*':
                    if len(p)>=2:
                        if p[-2] == s[-1] or p[-2] == '.':
                            # *匹配0个、一个或者多个
                            return match(s, p[:-2]) or match(s[:-1], p[:-2]) or match(s[:-1], p)
                        else:
                            # 不能匹配
                            return match(s, p[:-2])
            return False
        # 递归解法
        return match(s, p)

思路2: 动态规划（dp)

class Solution:
   def isMatch(self, s: str, p: str) -> bool:
       length_n = len(s)
       length_p = len(p)
       dp = [[False] * (length_p+1) for _ in range(length_n+1)]
       for i in range(length_n+1):
           for j in range(length_p+1):
               # 分成空正则和非空正则两种
               if j == 0:
                   dp[i][j] = i == 0
               else:
                   # 按照p[j]进行讨论
                   if p[j-1] == '*':
                       # 不看x*
                       if j >= 2:
                           dp[i][j] |= dp[i][j-2]
                       # 看
                       if i >= 1 and (s[i-1] == p[j-2] or p[j-2] == '.'):
                           dp[i][j] |= dp[i-1][j]
                   elif i > 0 and (p[j-1] == '.' or p[j-1] == s[i-1]):
                       dp[i][j] = dp[i-1][j-1]
       return dp[length_n][length_p]