正则表达式匹配

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

示例 5:

输入:
s = “mississippi”
p = “misisp*.”
输出: false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/regular-expression-matching
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        if not p :return not s
        test=( s) and ( p[0] in {s[0],'.'})
        if len(p)>=2and p[1]=='*':
            return ( self.isMatch(s,p[2:]))or (test and self.isMatch(s[1:],p) )
        else:
            return test and self.isMatch(s[1:],p[1:])

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        memo=dict()
        def dp(i,j):
            if (i,j) in memo:return memo[(i,j)]
            if j==len(p) :return i==len(s)
            test=(i<len(s))and (p[j]in {s[i],'.'})
            if j<=len(p)-2 and p[j+1]=='*':
                ans= dp(i,j+2)or (test and dp(i+1,j))
            else :
                ans=test and dp(i+1,j+1)
            memo[(i,j)]=ans
            return ans   
        return dp(0,0)

class Solution：
    def isMatch(self, s, p):
        if not p: return not s
        # s 和 p 首位置 匹配, 我们只需比较s的下一位和p是否匹配
        if s and len(p) >= 2 and (s[0] == p[0] or p[0] == ".") and p[1] == "*" and (
                self.isMatch(s[1:], p) ):
            return True
        # s 和 p 首位置不匹配, 但是p的下个位置是* 所以可以跳到p[2:]
        elif s and len(p) >= 2 and s[0] != p[0] and p[1] == "*" and self.isMatch(s, p[2:]):
            return True
        # s 和 p 首位置匹配, 接着匹配下一个
        elif s and (s[0] == p[0] or p[0] == ".") and self.isMatch(s[1:], p[1:]):
            return True
        # 防止s为空
        elif len(p) >= 2 and p[1] == "*" and self.isMatch(s, p[2:]):
            return True
        return False

1.p[j] == s[i]:dp[i][j] = dp[i-1][j-1]
2.p[j] == ".":dp[i][j] = dp[i-1][j-1]
3.p[j] =="*":
	3.1 p[j-1] != s[i]:dp[i][j] = dp[i][j-2]
	3.2 p[j-1] == s[i] or p[j-1] == ".": 
		dp[i][j] = dp[i-1][j] // 多个字符匹配
		or dp[i][j] = dp[i][j-2] // 没有匹配

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        #if not s or not p:
            #return False
        s_len = len(s)
        p_len = len(p)
        dp = [[False] * (p_len + 1) for _ in range(s_len + 1)]
        #print(dp)
        dp[0][0] = True
        for i in range(p_len):
            if p[i] == "*" and dp[0][i - 1]:
                dp[0][i + 1] = True
        #print(dp)
        for i in range(s_len):
            for j in range(p_len):
                if p[j] == s[i] or p[j] == ".":
                    dp[i + 1][j + 1] = dp[i][j]
                elif p[j] == "*":
                    if p[j - 1] != s[i]:
                        dp[i + 1][j + 1] = dp[i + 1][j - 1]
                    if p[j-1] == s[i] or p[j-1] == ".":
                        dp[i+1][j+1] = (dp[i][j+1]or  dp[i+1][j-1])
        #print(dp)
        return dp[-1][-1]

这个题的关键问题就是’*'号的处理问题，因为其可以匹配零个或者多个前面的内一个元素，所以当我们遍历遇到 '*'时我们不知道他是匹配了零个还是多个元素，或者说当他匹配多个元素的时候，我们不确定他是具体匹配了几个元素。
而我们解决的办法就是类似的通过当我们找到*时，先分成两种情况即其匹配零个元素或者多个元素，而对于多个元素的处理我们利用类似递归的思想或者说动态规划，一次我们只移动s的指针一次，这样呢当s中没有匹配的元素，或者说“ * ”匹配的元素数目到了之后，其下一次递归，或者遍历就是*对应零个元素了这样就解决了*的问题。

但说到这里我却发现了一个问题，就是这种解决的方法把*只匹配一个元素的情况也考虑了进来也判断其为正确的情况，但在测试中上述的做法通过了测试，但其确实也是将只匹配一个元素的情况考虑了进来，希望路过的大神能解答一下这个问题，嘻嘻。