《LeetCodeb笔记35》： 正则表达式匹配

题目：

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

说明:

s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

示例 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/regular-expression-matching

方法一：

动态规划+递归（比较暴力）

假设状态dp[i][j]表示s前i个字符可以与p的前j个字符匹配，那么我们最终要求的是dp[len(s)][len(p)]的状态，同时dp[i][j]又可以由之前的状态转移过来，不同的条件下，转移方式不同。

1.s[i]=p[j] or p[j]=='.'：dp[i][j] = dp[i-1][j-1]；

2.当p[j] = '*'号时，

如果p[j-1]=s[i],对于*号可以有三种同的状态，分别代表0、1以及大于1的重复数量，则

                dp[i][j] = dp[i][j-2] or dp[i][j-1] or dp[i-1][j]

如果p[j-1]!=s[i],则

       dp[i][j] = dp[i][j-2]

3.else:

       False

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        l1 = len(s)
        l2 = len(p)
        if l1 == 0 and l2 == 0:
            return True
        elif l1==0 and l2!=0:
            if p[-1]!='*':
                return False
            else:
                return self.isMatch(s, p[:l2 - 2])
        elif l2 == 0 and l1!=0:
            return False 
        if s[-1]==p[-1] or p[-1] == '.':
            return self.isMatch(s[:l1-1], p[:l2-1])
        elif p[-1] == '*':
            if p[-2]==s[-1] or p[-2]=='.':
                return self.isMatch(s[:l1-1], p[:l2]) or self.isMatch(s[:l1], p[:l2-1]) or self.isMatch(s[:l1], p[:l2-2])
            if p[-2]!=s[-1]:
                return self.isMatch(s, p[:l2-2])
        else:
            return False

方法二：

动态规划+递归+记忆性

解题思路同方法一，增加一个状态矩阵来储存已经匹配过的状态。

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        ls = len(s)
        lp = len(p)
        dp = [[0]*(lp+1) for i in range(ls+1)]
        dp[0][0] = True        
        return self.match_str(s, p, dp)

    def match_str(self, s, p, dp):
        ls = len(s)
        lp = len(p)
        if ls==0 and lp==0:
            dp[ls][lp] = True
        elif lp==0:
            dp[ls][lp] = False
        elif ls==0 and p[-1]!='*':
           dp[ls][lp] = False
        elif ls==0 and p[-1]=='*':
           dp[ls][lp] = self.match_str(s, p[:-2], dp)   

        if isinstance(dp[ls][lp], bool):
            return dp[ls][lp]

        if s[-1]==p[-1] or p[-1]=='.':
            dp[ls][lp] = self.match_str(s[:-1], p[:-1], dp)
        elif p[-1]=='*':
            if p[-2]==s[-1] or p[-2]=='.':
                dp[ls][lp] = self.match_str(s, p[:-1], dp) or self.match_str(s, p[:-2], dp) or self.match_str(s[:-1], p, dp)
            else:
                dp[ls][lp] = self.match_str(s, p[:-2], dp)            
        else:
            dp[ls][lp] = False
        return dp[ls][lp]