LeetCode 10 正則表達式匹配

LeetCode 10 正則表達式匹配

題目

給你一個字符串 s 和一個字符規律 p，請你來實現一個支持 ‘.’ 和 ‘*’ 的正則表達式匹配。

‘.’ 匹配任意單個字符
‘*’ 匹配零個或多個前面的那一個元素
所謂匹配，是要涵蓋 整個 字符串 s的，而不是部分字符串。

說明:

s 可能爲空，且只包含從 a-z 的小寫字母。
p 可能爲空，且只包含從 a-z 的小寫字母，以及字符 . 和 *。
示例 1:

輸入:
s = “aa”
p = “a”
輸出: false
解釋: “a” 無法匹配 “aa” 整個字符串。

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/regular-expression-matching
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。

分析

本來這道題想用之前學習的動態規劃來練練手，結果還是搞不出來，動態規劃前面的分析還是能夠搞得出來，但是後面的分析有點理不清楚：題解思路如下。
方法一：回溯
首先，我們考慮只有 ‘.’ 的情況。這種情況會很簡單：我們只需要從左到右依次判斷 s[i] 和 p[i] 是否匹配。

def isMatch(self,s:str, p:str) -> bool:
    if not p: return not s # 邊界條件

    first_match = s and p[0] in {s[0],'.'} # 比較第一個字符是否匹配

    return first_match and self.isMatch(s[1:], p[1:])

如果有星號，它會出現在 p[1] 的位置，這時有兩種情況：

星號代表匹配 0 個前面的元素。如 ‘##’ 和 a*##，這時我們直接忽略 p 的 a*，比較 ## 和 ##；
星號代表匹配一個或多個前面的元素。如 aaab 和 ab，這時我們將忽略 s 的第一個元素，比較 aab 和 ab。
以上任一情況忽略掉元素進行比較時，剩下的如果匹配，我們認爲 s 和 p 是匹配的。

代碼

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        if not p: return not s
        # 第一個字母是否匹配
        first_match = s and p[0] in {s[0],'.'}
        # 如果 p 第二個字母是 *
        if len(p) >= 2 and p[1] == "*":
            return self.isMatch(s, p[2:]) or \
            first_match and self.isMatch(s[1:], p)
        else:
            return first_match and self.isMatch(s[1:], p[1:])

方法二：動態規劃
狀態
很容易想到，dp[i][j] 表示的狀態是 s 的前 i 項和 p 的前 j 項是否匹配。

轉移方程
現在如果已知了 dp[i-1][j-1] 的狀態，我們該如何確定 dp[i][j] 的狀態呢？我們可以分三種情況討論，其中，前兩種情況考慮了所有能匹配的情況，剩下的就是不能匹配的情況了：

s[i] == p[j] or p[j] == ‘.’：比如 abb 和 abb，或者 abb 和 ab. ，很容易得到 dp[i][j] = dp[i-1][j-1] = True。因爲 ab 和 ab 是匹配的，如果後面分別加一個 b，或者 s 加一個 b 而 p 加一個 . ，仍然是匹配的。

p[j] == ‘*’：當 p[j] 爲星號時，由於星號與前面的字符相關，因此我們比較星號前面的字符 p[j-1] 和 s[i] 的關係。根據星號前面的字符與 s[i] 是否相等，又可分爲以下兩種情況：

p[j-1] != s[i]：如果星號前一個字符匹配不上，星號匹配了 0 次，應忽略這兩個字符，看 p[j-2] 和 s[i] 是否匹配。 這時 dp[i][j] = dp[i][j-2]。
p[j-1] == s[i] or p[j-1] == ‘.’:星號前面的字符可以與 s[i] 匹配，這種情況下，星號可能匹配了前面的字符的 0 個，也可能匹配了前面字符的多個，當匹配 0 個時，如 ab 和 abb*，或者 ab 和 ab.* ，這時我們需要去掉 p 中的 b* 或 .* 後進行比較，即 dp[i][j] = dp[i][j-2]；當匹配多個時，如 abbb 和 ab*，或者 abbb 和 a.*，我們需要將 s[i] 前面的與 p 重新比較，即 dp[i][j] = dp[i-1][j]
其他情況：以上兩種情況把能匹配的都考慮全面了，所以其他情況爲不匹配，即 dp[i][j] = False

將以上進行歸納得到狀態轉移方程

代碼

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        # 邊界條件，考慮 s 或 p 分別爲空的情況
        if not p: return not s
        if not s and len(p) == 1: return False

        m, n = len(s) + 1, len(p) + 1
        dp = [[False for _ in range(n)] for _ in range(m)]
        # 初始狀態
        dp[0][0] = True
        dp[0][1] = False

        for c in range(2, n):
            j = c - 1
            if p[j] == '*':
                dp[0][c] = dp[0][c - 2]
        
        for r in range(1,m):
            i = r - 1
            for c in range(1, n):
                j = c - 1
                if s[i] == p[j] or p[j] == '.':
                    dp[r][c] = dp[r - 1][c - 1]
                elif p[j] == '*':       # ‘*’前面的字符匹配s[i] 或者爲'.'
                    if p[j - 1] == s[i] or p[j - 1] == '.':
                        dp[r][c] = dp[r - 1][c] or dp[r][c - 2]
                    else:                       # ‘*’匹配了0次前面的字符
                        dp[r][c] = dp[r][c - 2] 
                else:
                    dp[r][c] = False
        return dp[m - 1][n - 1]

結尾
遞歸的方法思路比較簡單，動態規劃中處理星號和點的時候，需要將細節考慮清楚，這樣寫代碼的時候就容易了~加油！

作者：ml-zimingmeng
鏈接：https://leetcode-cn.com/problems/regular-expression-matching/solution/hui-su-he-dong-tai-gui-hua-by-ml-zimingmeng/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。