LeetCode 10. 正則表達式匹配 | Python

時間 2020-05-03

標籤 leetcode 正則表達式匹配 python 欄目正則表達式简体版

原文原文鏈接

10. 正則表達式匹配

題目來源：https://leetcode-cn.com/problems/regular-expression-matchingpython

題目

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

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

說明:數組

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

示例 1:bash

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

示例 2:微信

輸入:
s = "aa"
p = "a*"
輸出: true
解釋: 由於 '*' 表明能夠匹配零個或多個前面的那一個元素, 在這裏前面的元素就是 'a'。所以，字符串 "aa" 可被視爲 'a' 重複了一次。

示例 3:spa

輸入:
s = "ab"
p = ".*"
輸出: true
解釋: ".*" 表示可匹配零個或多個（'*'）任意字符（'.'）。

示例 4:code

輸入:
s = "aab"
p = "c*a*b"
輸出: true
解釋: 由於 '*' 表示零個或多個，這裏 'c' 爲 0 個, 'a' 被重複一次。所以能夠匹配字符串 "aab"。

示例 5:blog

輸入:
s = "mississippi"
p = "mis*is*p*."
輸出: false

解題思路

暴力解

先從【暴力解】的角度理清問題。遞歸

這個題目中，難點就在於處理 . 和 * 兩個符號。

若是隻是要求檢查兩個普通字符是否匹配。那麼經過直接遍歷，檢查每一個數組對應的元素是否相同來判斷是否匹配便可。例如：

def isMatch(s, p):
    if len(s) != len(p):
        return False
    for i in range(p):
        if s[i] != p[i]:
            return False
    return True

那代碼大概就會是這樣。那咱們用遞歸的形式來書寫，如下爲僞代碼：

def isMatch(s, p):
    """
    s: text
    p: pattern
    """
    if p is empty:
        return s is empty
    first_match = (s not empty) and p[0] == s[0]
    return first_match and isMatch(s[1:], p[1:])

在上面的代碼中，其實就是經過先判斷前面的元素是否匹配，逐層往下判斷後面的元素是否也匹配，從而來找到答案。

如今來處理兩個符號的問題，. 這個符號，表示的是匹配處換行符之外的任意字符（這裏就不展開說明了，若需詳細瞭解，可直接上網搜索）。

瞭解這個符號的含義後，這裏所能表達的意義，也會相應的改變，便是說，當 p 中出現 . 號，s 對應的元素不管是什麼字符（題目說明 s 僅包含 a-z 字符）都可以匹配，如今根據上面的僞代碼進行修改：

def isMatch(s, p):
    """
    s: text
    p: pattern
    """
    if not p:
        return not s
    first_match = bool(s) and p[0] in {s[0], '.'}
    return first_match and isMatch(s[1:], p[1:])

這裏惟一不一樣的就是 first_match 這部分的判斷中，由於 p 中的元素可能出現固定字符，或者 . 號，因此當 p 出現的字符與 s 中對應的字符相同，或者 p 此處是 . 字符，這裏二者都表示可以匹配。

那麼如今往下看 * 符號，這個符號表示的含義是重複零次或屢次。那麼這裏最明顯的字符就是重複多少次的問題？在這裏考慮使用遞歸的方式書寫，假設重複 n 次，其實這裏先不須要考慮 n 是多少，把這個交給遞歸實現。要考慮那麼當下的狀況，這裏應該就只有兩個選擇，要麼是匹配 0 次，要麼是匹配 1 次。

那麼相應的代碼就應該修改成（這裏書寫發現 * 的狀況）：

# 這裏表示發現 `*` 的狀況下，
if len(p) >= 2 and p[1] == '*':
    # 這裏須要考慮匹配 0 次的問題，例如 aa，c*aa
    # 也要考慮匹配屢次的問題，例如 aa, a*
    return isMatch(s, p[2:]) or first_match and isMatch(s[1:], p)

在這段代碼當中，isMatch(s, p[2:]) 這裏表示，字符匹配 0 次，跳過 p 中字符與 * 結合這部分。後面的表示，p[0] 和 s[0] 匹配以後，繼續判斷 s 接下來的元素。其中保留 p，只向後移動 s，是爲了實現 * 匹配屢次的功能。

這樣來看，其實已經能夠說理清兩個符號的具體實現方式。

關於完整的代碼請查看【代碼實現】部分。

動態規劃

思路：動態規劃

在上面暴力解的方法中，頻繁使用切片操做，複雜度高。這裏在暴力解的基礎上，使用動態規劃的方法，定義變量 i，j 來記錄當前匹配到的位置，用 dp(i, j) 表示 s[i:] 和 p[j:] 是否可以匹配。，避免頻繁切片。這裏也引入備忘錄的概念，用來避免重複的運算。

具體代碼一樣請查看【代碼實現】部分。

代碼實現

暴力解 | 代碼實現

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        if not p:
            return not s

        first_match = bool(s) and p[0] in {s[0], '.'}

        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:])

動態規劃 | 代碼實現

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        memo = {}
        def dp(i, j):
            if (i, j) not in memo:
                if j == len(p):
                    return i == len(s)

                else:
                    first_match = i < len(s) and p[j] in {s[i], '.'}
                    if j + 1 < len(p) and p[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)