递归|动态规划-困难-leetcode. 正则表达式匹配

想找个难的开始练手，于是。。。真的卡了很久。

leetcode的正则表达式匹配题。标记是困难。可以用递归或动态规划两种方法解决（递归时间较慢，动态规划打表处理，空间换时间）

 问题描述

给定一个字符串 (s) 和一个字符模式 (p)。实现支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符。
'*' 匹配零个或多个前面的元素。

匹配应该覆盖整个字符串 (s) ，而不是部分字符串。

说明:

• s 可能为空，且只包含从 a-z 的小写字母。
• p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

 

示例比较多，这里我直接搬链接leet code 10. 正则表达式匹配

然后接下来分别讲讲我的递归和动态规划两种方法的思路和代码吧

ps:递归的代码有点乱，其实我一开始做就是有点乱，不过没关系啦，递归思路不难，主体代码出来之后自己完善特殊情况代码就出来了。

递归思路

1. 核心思路与LR字符串交换类似
2. 两字符相等或当前模式串字符为.则匹配
3. 注意*是0次以上
4. 当为*的时候实际应该循环处理。即前一字符出现0次循环至前一字符最后一次连续出现的情况依次匹配
5. 主体框架出来后，剩下的就是处理特殊情况提交测试了
6. ps:应该注意代码结构过于混乱且难以AC时建议重新整理思路

我的递归代码比较慢，447个样例68毫秒，在所有AC记录里面排中间，如果要更快的速度，只能上动态规划。有兴趣的同学可以继续看本文后面的动态规划办法。

另外，我在网上看别人的代码，发现有很多种不同的思路，有兴趣的同学可以自己查查，有些思路挺有意思的。

递归代码

bool isMatch(string s, string p) {
    unsigned long sLen = s.length(), pLen = p.length();
    char pChar = 0, sChar = 0;
    unsigned long i = 0, j = 0, k = 0;

    if (!pLen)
        return !sLen;

    if (!sLen) {
        if (pLen == 2) {
            return p[1] == '*';
        } else if (pLen > 2) {
            return p[1] == '*' && this->isMatch(s, p.substr(2));
        } else {
            return false;
        }
    }

    while (i < pLen && j < sLen) {
        pChar = p[i];
        sChar = s[j];
        // 是字符则简单匹配，通配符则特殊处理
        if ((pChar == sChar || pChar == '.') && p[i+1] != '*') {
            i++;
            j++;
        } else if (pChar == '*') {
            pChar = p[i-1];
            string pSub = p.substr(i + 1);
            unsigned long pSubLen = pSub.length();
            if (pSubLen > 0) {
                while (j < sLen && (s[j] == pChar || pChar == '.')) {
                    if (this->isMatch(s.substr(j), pSub)) {
                        return true;
                    }
                    j++;
                }
                return this->isMatch(s.substr(j), pSub);
            } else {
                while (j < sLen && (s[j] == pChar || pChar == '.')) {
                    j++;
                }
                return j == sLen || this->isMatch(s.substr(j), pSub);
            }
        } else if (p[i+1] == '*') {
            i++;
        } else {
            return false;
        }
    }
    return (i == pLen && j == sLen) || this->isMatch(s.substr(j), p.substr(i));
}

 

动态规划思路

1. 取二维数组dp[i][j]，表示当s[i]至p[j]为止是否匹配
2. 若dp[i][j]匹配则前一位即dp[i-1][j-1]一定匹配
3. 当前两个字符是否匹配，取决于两个字符是否相等或模式串p中的对应字符是否为单字符匹配通配符「.」
4. 处理特殊情况，当前模式串的对应字符为*时，则匹配串对应字符要么与前一模式串对应字符匹配。或前两位匹配状态为true，即dp[i][j-2]==true（表示*对应的字符出现0次）

需要注意存在以下情况。

1. 遇到*时，需要回溯至前一位是否匹配
2. 当于*对应的字符不匹配时，需要回溯至前两位
3. *仅可能出现在第2位及以后

因此dp表横纵都+1，dp[i][j]对应s[i-1]p[j-1]，dp[0][0]就能表示两个空串的匹配结果（true）。
这样一来能减少特殊情况处理（我一开始就是一直在这里懵逼，卡了半天没有全部AC，最后还是看别人博客的题解的。。。）

 

动态规划代码 

 443个样例8ms，全部AC

 

 bool isMatchForDp(string s, string p) {
        unsigned long sLen = s.length(), pLen = p.length();

        // 遇到*时，需要回溯至前一位是否匹配
        // 当于*对应的字符不匹配时，需要回溯至前两位
        // *仅可能出现在第2位及以后
        // 因此横纵都+1能减少特殊处理
        vector<vector<bool> > dp(sLen + 1, vector<bool>(pLen + 1, false));
        char pChar;
        unsigned long sFix = 0, pFix = 0;

        dp[0][0] = true;

        for (sFix = 0; sFix <= sLen; sFix++) {
            for (pFix = 1; pFix <= pLen; pFix++) {
                pChar = p[pFix - 1];
                if (pChar == '*') {
                    pChar = p[pFix - 2];
                    dp[sFix][pFix] = dp[sFix][pFix - 2] ||  // *对应字符一次都不出现，问题转化为与前一字符是否匹配
                                     (sFix > 0 && dp[sFix - 1][pFix] &&
                                      // 若当前匹配字符与模式串相应位的前一字符匹配，则前一匹配字符一定也与模式串相应位的前一字符匹配
                                      (s[sFix - 1] == pChar || pChar == '.'));
                } else {
                    // sFix = 0描述匹配串为空时的情况，匹配永远为false
                    // 当前匹配，则左上角一定匹配（之前的串已匹配）
                    dp[sFix][pFix] = sFix > 0 && dp[sFix - 1][pFix - 1] && (s[sFix - 1] == pChar || pChar == '.');
                }
            }
        }

        return dp[sLen][pLen];
}

 

 

最后，说一件悲伤的事情

这道题

我看到有人

用python

一句话搞定（手动微笑脸）

这种函数都能被允许使用的吗？

class Solution(object):
    def isMatch(self, s, p):
        return re.match('^' + p + '$', s) != None
        

没错。python就调用re包，调个函数就行了。。。。 

 不过执行比用C++递归还慢。考虑可能是因为match还会多出逻辑匹配其他通配符的原因。如果用python动态规划实现，速度就会有所提升。