LeetCode:10. Regular Expression Matching

LeetCode:10. Regular Expression Matching

Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '*'.

'.' Matches any single character.
'*' Matches zero or more of the preceding element.
The matching should cover the entire input string (not partial).

Note:

s could be empty and contains only lowercase letters a-z.
p could be empty and contains only lowercase letters a-z, and characters like . or *.

Example 1:

Input:
s = "aa"
p = "a"
Output: false
Explanation: "a" does not match the entire string "aa".

Example 2:

Input:
s = "aa"
p = "a*"
Output: true
Explanation: '*' means zero or more of the precedeng element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".

Example 3:

Input:
s = "ab"
p = ".*"
Output: true
Explanation: ".*" means "zero or more (*) of any character (.)".

Example 4:

Input:
s = "aab"
p = "c*a*b"
Output: true
Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore it matches "aab".

Example 5:

Input:
s = "mississippi"
p = "mis*is*p*."
Output: false

正则表达式匹配，这里只用了两个符号：* 和 .

思路一：递归

首先明确的是 * 只会出现在一个字符或者 . 之后。

1. 如果text和pattern第一个字符匹配（相等或者patter第一个字符为.）且pattern第二个字符不是 * ，则递归判断 text 从第二个字符开始向后的子串以及pattern第二个字符向后的子串。
2. 如果pattern第二个字符是 * ，有两种情况：
   (1) * 匹配了0个字符，递归判断text以及patter从第三位开始向后的子pattern。也就是 self.isMatch(text, pattern[2:])。这种情况可以保证第一个字符不相等的时候跳过pattern的前两位。
   (2) * 匹配了一个或多个字符，这种情况需要第一个字符相等，也就是下面的 first_match 为True，然后递归判断text第二个字符开始的子串以及整个pattern。这种情况保证了pattern第一个字符和 * 必须至少一个字符，然后向后匹配多个相同的字符。

Python 代码实现

class Solution(object):
    def isMatch(self, text, pattern):
        if not pattern:
            # 如果pattern为空，则返回text是否为空
            return not text

        # 判断第一个字符是否匹配
        first_match = bool(text) and pattern[0] in {text[0], '.'}

        if len(pattern) >= 2 and pattern[1] == '*':
            # 注意这里：self.isMatch(text, pattern[2:])表示X*匹配0个字符，如果这种情况可以匹配成功直接返回True。否则就让X*匹配一个或多个字符，这种情况首先就要保证first_match为True
            return (self.isMatch(text, pattern[2:]) or (first_match and self.isMatch(text[1:], pattern)))
        else:
            return first_match and self.isMatch(text[1:], pattern[1:])

还有一种从后向前的暴力求解法：

* 不会单独出现，它一定是和前面一个字母或".“配成一对。看成一对后"X*”，它的性质就是：要不匹配0个，要不匹配连续的“X”.所以尝试暴力解法的时候一个trick是从后往前匹配.

是这样来分情况看的:

1. 如果s[i] = p[j] 或者 p[j]= . ，则往前匹配一位。
2. 如果p[j] = * , 检查一下，如果这个时候p[j-1] = . 或者p[j-1] = s[i] ，那么就往前匹配，如果这样能匹配过，就return True（注意如果这样不能最终匹配成功的话我们不能直接返回False，因为还可以直接忽略' X* '进行一下匹配试试是否可行）， 否则我们忽略 ’ X* '（也就是匹配0个字符）,这里注意里面的递推关系。
3. 再处理一下边界状况：
   • s已经匹配完了， 如果此时p还有，那么如果剩下的是 X* 这种可以过，所以检查
   • p匹配完毕，如果s还有那么报错

Python 代码实现

class Solution(object):
    def isMatch(self, s, p):
        def helper(s, i, p, j):
            if j == -1:
                #模式串遍历完成，看原始字符串有没有遍历完成
                return i == -1
            if i == -1:
                if p[j] != '*':
                    #原始字符串有没有遍历完成，模式串如果不是*肯定不能匹配完成
                    return False 
                else:
                    #原始字符串有没有遍历完成，模式串还有*，继续匹配
                    return helper(s, i, p, j-2)
            if p[j] == '*':
                if p[j-1] == '.' or p[j-1] == s[i]:
                    if helper(s, i-1, p, j):
                        # 试探性向前匹配以为，所以这里的j不变，如果成功则返回True
                        return True
                    else:
                        # 如果成功则跳过这两个字符，j-2，继续匹配
                        return helper(s, i, p, j-2)
            if p[j] == '.' or p[j] == s[i]:
                # 单个字符匹配
                return helper(s, i-1, p, j-1)
            return False

        return helper(s, len(s)-1, p, len(p)-1)

思路二：动态规划

设dp(i, j)表示: text[i:] 和 pattern[j:] 匹配，将每个(i,j)保存起来。最后返回dp(0,0)就是要求的text和pattern是否匹配

Python 代码实现

# dp
class Solution(object):
    def isMatch(self, text, pattern):
        memo = {}
        def dp(i, j):
            if (i, j) not in memo:
                if j == len(pattern):
                    ans = i == len(text)
                else:
                    first_match = i < len(text) and pattern[j] in {text[i], '.'}
                    if j+1 < len(pattern) and pattern[j+1] == '*':
                        ans = dp(i, j+2) or first_match and dp(i+1, j)
                    else:
                        ans = first_match and dp(i+1, j+1)

                memo[i, j] = ans
            return memo[i, j]

        return dp(0, 0)

---

THE END.