leetcode--面试题19. 正则表达式匹配

 题目来自LeetCode，链接：面试题19. 正则表达式匹配。具体描述为：请实现一个函数用来匹配包含.和*的正则表达式。模式中的字符.表示任意一个字符，而*表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串aaa与模式a.a和ab*ac*a匹配，但与aa.a和ab*a均不匹配。

• 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

 先给出一种递归的解法如下：

• 判断模式串p长度是否为0，是的话如果匹配串s的长度也为0则匹配成功，否则匹配失败；
• 如果模式串p长度不小于2且第二个字符为*，说明可以匹配任意个c（c为当前模式串p第一个字符），但是这里只需要判断两种情况：匹配0个（match(sIdx, pIdx+2)）和1个c（sLen > 0 && (sChar[sIdx] == pChar[pIdx] || pChar[pIdx] == '.') && match(sIdx + 1, pIdx)），因为更多个c的情况会在递归（match(sIdx + 1, pIdx)）中被判断；
• 如果模式串p长度小于2或第二个字符不为*，则需要两者第一个字符匹配上并且除去第一个字符之后的字符串（这里用递归）也匹配上。

 JAVA版代码如下：

class Solution {
    private char[] sChar;
    private char[] pChar;
    private boolean match(int sIdx, int pIdx) {
        int sLen = sChar.length - sIdx, pLen = pChar.length - pIdx;
        if (pLen == 0) {
            // p为空的情况下必须s也为空才能匹配成功
            return sLen == 0;
        }
        // 根据p的第二位是否为*，分两种情况
        if (pLen >= 2 && pChar[pIdx + 1] == '*') {
            // 可以匹配任意个p[pIdx]，尝试匹配0个和1个，注意超过1个的会在match(sIdx+1, pIdx)里面被递归到
            return match(sIdx, pIdx + 2) || (sLen > 0 && (sChar[sIdx] == pChar[pIdx] || pChar[pIdx] == '.') && match(sIdx + 1, pIdx));
        }
        else {
            // 第二位不为*，那么当前位就必须匹配上了，然后再看后面的是否匹配
            return sLen > 0 && (sChar[sIdx] == pChar[pIdx] || pChar[pIdx] == '.') && match(sIdx + 1, pIdx + 1);
        }
    }
    
    public boolean isMatch(String s, String p) {
        sChar = s.toCharArray();
        pChar = p.toCharArray();
        return match(0, 0);
    }
}

 提交结果如下:

 然后是动态规划的方法，假设dp[i][j]表示匹配串s的前i个字符与模式串p的前j个字符是否匹配。为了求dp[i][j]，可以根据模式串p的第j个字符p[j-1]分情况讨论：

• 不为*：只有同时满足以下两个条件才匹配成功：
  • 模式串p的第j个字符p[j-1]跟匹配串第i个字符s[i-1]匹配成功
  • 模式串p的前j-1个字符与匹配串前i-1个字符匹配成功（即dp[i-1][j-1]）
• 为*：说明可以匹配任意个p[j-2]，这里分为两种情况：
  • 匹配0个p[j-2]，则是否匹配成功取决于模式串p的前j-2个字符与匹配串前i个字符匹配成功（即dp[i][j-2]）
  • 匹配至少一个p[j-2]，直接看模式串p的前j个字符与匹配串前i-1个字符是否匹配成功即可（即dp[i-1][j]）

 JAVA版代码如下：

class Solution {
    
    public boolean isMatch(String s, String p) {
        char[] sChar = s.toCharArray(), pChar = p.toCharArray();
        int m = sChar.length, n = pChar.length;
        // dp[i][j]: s的前i个与p的前j个是否匹配
        boolean[][] dp = new boolean[m + 1][n + 1];
        dp[0][0] = true;
        // s为空的时候p必须是a*b*c*的形式才能匹配成功
        for (int j = 2; j <= n; j += 2) {
            if (pChar[j - 1] == '*') {
                dp[0][j] = true;
            }
            else {
                break;
            }
        }
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (pChar[j - 1] != '*') {
                    // 不为*的情况，是否匹配成功取决于当前字符是否相同及去掉当前字符之后前面的字符串是否匹配成功
                    dp[i][j] = (pChar[j - 1] == '.' || pChar[j - 1] == sChar[i - 1]) && dp[i - 1][j - 1];
                }
                else {
                    // 为*的情况，分为匹配0个及多个的情况（需要字符匹配上）
                    if (j >= 2) {
                        // 匹配0个或至少一个
                        dp[i][j] = dp[i][j - 2] || ((pChar[j - 2] == '.' || sChar[i - 1] == pChar[j - 2]) && dp[i -1][j]);
                    }
                }
            }
        }
        return dp[m][n];
    }
}

 提交结果如下:

 Python版代码如下：

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        m = len(s)
        n = len(p)
        dp = [[False for _ in range(n + 1)] for _ in range(m + 1)]
        dp[0][0] = True
        j = 2
        while j <= n:
            if p[j - 1] == '*':
                dp[0][j] = True
                j += 2
            else:
                break
        
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if p[j - 1] != '*':
                    dp[i][j] = (s[i - 1] == p[j - 1] or p[j - 1] == '.') and dp[i - 1][j - 1]
                else:
                    if j >= 2:
                        dp[i][j] = dp[i][j - 2] or ((s[i - 1] == p[j - 2] or p[j - 2] == '.') and dp[i - 1][j])
        return dp[m][n]

 提交结果如下: