leetcode python3 正则表达式匹配

给你一个字符串 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

该题的标签是困难，但该题在面试中经常出现，是应该引起重视的一道题，首先可以考虑迭代法，使用迭代法原始实现这个问题，

class Solution:

    def isMatch(self, s: str, p: str) -> bool:

        slen = len(s)

        plen = len(p)

        # 当长度为0时，判断是否长度都为0

        if plen == 0:

            return slen == 0

        # 当长度为1时，判断两个字符串是否相等或p为‘.’

        if plen == 1:

            return ((s == p) or (slen == 1 and p[0] == '.'))

        # 判断长度大于1时，先判断无‘*’，迭代判断就ok了

        if p[1] != '*':

            if slen == 0:

                return False

            return ((s[0] == p[0] or p[0] == '.') and self.isMatch(s[1:], p[1:]))

        # 判断有‘*’时，先判断第一位，

        while (len(s) != 0) and (s[0] == p[0] or p[0] == '.'):

            if self.isMatch(s, p[2:]):

                return True

            s = s[1:]

        return self.isMatch(s, p[2:])

因为是使用迭代法，因此首先要根据不同长度进行分析，当长度为0时，二者都为0即匹配，当p长1时，判断s与p相等，或p为‘.’，该题的关键在于‘*’的匹配，‘*’可以匹配0个之前字符，也可以匹配多个前个字符，因此要单独讨论。

（1）匹配0个之前字符的时候，递归比较s和p[2:]就可以

（2）匹配多个字符的时候，匹配s[1:]和p

虽然递归可以实现，但效果并不理想，也不会是面试官想考察的东西，这道题最基本的思想就是动态规划，动态规划的题目首先要考虑的是状态dp：dp[i][j]表示的 s的前i个字符是否能被p的前j个字符匹配

状态转移方程：dp[i-1][j-1]下，最简单的是s[i]==p[j]，然后是p[j]=="."，此时dp[i][j]==dp[i-1][j-1]，方程的关键是p[j]=="*"时的处理，用p去匹配s时，定义二维表格dp，因为要考虑字符长度为0的情况，因此大小为len(p)+1 * len(s) + 1，因为‘*’的特殊性，因此最好可以从后向前推，判断最后一个字符的情况，如果不是‘*’，就可以按等值或是‘.’匹配，如果是‘*’，就判断倒数第二位

看到有个博主写的很明白：1. 当s的当前末尾s[i-1]和p的当前末尾p[j-1]匹配时，即s[i-1] == p[j-1] or p[j-1] == '.'
                很显然dp[i][j] = dp[i-1][j-1]
            2.否则如果p的末尾p[j-1]是'*'的话，因为星号*一定不会单独出现，所以看其前一个位置p[j-2]的字符情况，
              相当于现在是这么个状态，小写s是当前字符串的最后一个字符，大写S是前面的字符串，p同理，现在要判断的就是
              s和p*的情况，小p就是p[j-2]了
                S   s
                P p *
              ------------
              A:
                如果不匹配，即p[i-2] != '.' and p[j-2] != s[i-1]:
                显然dp[i][j] = dp[i][j-2]，看看前i个字符和模式的j-2的情况
              B：
               二者匹配，即p[i-2] == '.' or p[j-2] == s[i-1]
               那么当前的这个a就要将情况划分成三种来看：当前匹配的a是P中的第0次，第1次还是第N次的a
               因为a*代表的就是三种，a要出现0次，1次，或者多次，所以现在就将这个a去按着三种划分并比较
               S   a
               P a *
              ------------
               S的a是模式中出现0次意义的a：
                    就相当于(S a) 与 P 匹配
                    dp[i][j] = dp[i][j-2]
               S的a是模式中出现1次意义的a：
                    相当于(S a) 与 (P a)匹配，
                    dp[i][j] = dp[i][j-1]
               S的a是模式中出现多次意义的a：
                    相当匹配的是 S a与P aaaaaa，则现在S中末尾的这个a出现前已经有若干个a出现了，那么匹配的
                关键就是S能和P aaaaaa匹配
                    dp[i][j] = dp[i-1][j]

class Solution:

    def isMatch(self, s: str, p: str) -> bool:

        # 定义dp数组

        dp = [[False] * (len(p) + 1) for _ in range(len(s) + 1)]

        # p长度为0时只能匹配s为0时的情况

        dp[0][0] = True

        # s为0时，可以匹配p为a*、a*b*这种情况

        for j in range(1, len(p) + 1):

            if p[j - 1] == '*' and dp[0][j - 2]:

                dp[0][j] = True

        # s为原始串，s在前，p为匹配串，p在后

        for i in range(1, len(s) + 1):

            for j in range(1, len(p) + 1):

                # 相等或p为‘.’时

                if s[i - 1] == p[j - 1] or p[j - 1] == '.':

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

                # p为‘*’时

                elif p[j - 1] == '*':

                    # 如果不匹配，就直接去掉*和*之前的字符进行匹配

                    if p[j - 2] != '.' and p[j - 2] != s[i - 1]:

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

                    # 如果匹配，就要考虑*之前的字符是第几次出现

                    else:

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

        return dp[-1][-1]