【Leetcode】10. 正则表达式匹配 【字符串、动态规划】

给定一个字符串 ($s$) 和一个字符模式 ($p$)。实现支持 ‘$.$’ 和 ‘$\ast$’ 的正则表达式匹配。

‘$.$’ 匹配任意单个字符。
‘$\ast$’ 匹配零个或多个前面的元素。
匹配应该覆盖整个字符串 ($s$) ，而不是部分字符串。

说明:

$s$ 可能为空，且只包含从 $a-z$ 的小写字母。
$p$ 可能为空，且只包含从 $a-z$ 的小写字母，以及字符 $.$ 和 $\ast$。
示例 $1$:

输入:s = “$aa$”
p = “$a$”
输出: $false$
解释: “$a$” 无法匹配 “$aa$” 整个字符串。
示例 $2$:

输入:
$s$ = “$aa$”
$p$ = “$a\ast$”
输出: $true$
解释: ‘$\ast$’ 代表可匹配零个或多个前面的元素, 即可以匹配 ‘$a$’ 。因此, 重复 ‘$a$’ 一次, 字符串可变为 “$aa$”。
示例 $3$:

输入:
$s$ = “$ab$”
$p$ = “$.\ast$”
输出: $true$
解释: “$.\ast$” 表示可匹配零个或多个(’$\ast$’)任意字符(’$.$’)。
示例 $4$:

输入:
$s$ = “$aab$”
$p$ = “$c\ast a\ast b$”
输出: $true$
解释: ‘$c$’ 可以不被重复, ‘$a$’ 可以被重复一次。因此可以匹配字符串 “$aab$”。
示例 $5$:

输入:
$s$ = “$mississippi$”
$p$ = “$mis\ast is\ast p\ast .$”
输出: $false$

思路：

1）递归。

• 如果$p$的下一个字符为$\ast$，那么$(1)$当$s$不为空且$p[0]=s[0]$或$p[0]{=}^{\prime }{.}^{\prime }$，即该位能够匹配时，那么这个时候由于$\ast$可以匹配多个前面字符，则递归描述为$(s+1,p)$，在这里采取截取字符串的方式，$(s.substr(1),p)$ $(2)$当不满足$(1)$条件时，则递归描述为$(s,p.substr(2))$
• 如果$p$的下一个字符不为$\ast$，那么只有两个字符匹配，即$s$不为空且$p[0]=s[0]$或$p[0]{=}^{\prime }{.}^{\prime }$成立时，才能继续匹配下一个字符，递归描述为$(s.substr(1),p.substr(1))$

class Solution {
public:
    bool isMatch(string s, string p) {
        if (p.empty()) return s.empty();
        if (p.size() > 1 && p[1] == '*') {
        	//两种匹配方式
            return isMatch(s, p.substr(2)) || 
            (!s.empty() && (s[0] == p[0] || p[0] == '.') 
            && isMatch(s.substr(1), p));
        } else {
        	//满足前面条件才能继续匹配
            return !s.empty() && (s[0] == p[0] || 
            p[0] == '.') && isMatch(s.substr(1), p.substr(1));
        }
    }
};

2）动态规划。实则对上述递归表达的解析。

• $dp[i][j]=true$描述为$s$中前$i$个字符与$p$中前$j$个字符匹配
• 如果$p[j-1]{=}^{\prime }{\ast }^{\prime }$，那么对应上述的第$1)$种情况，则有$dp[i][j]=dp[i][j-2]$ || ($i>0$ && ($s[i-1]==p[j-2]||p[j-2]={=}^{\prime }{.}^{\prime }$ ) && $dp[i-1][j]$，即将上述的分析逆转一下
• 如果p[j - 1] != ‘*’，那么对应上述的第2)种情况，则有$dp[i][j] = i > 0 && dp[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '.

class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size(), n = p.size();
        bool dp[m + 1][n + 1];
        memset(dp, false, sizeof(dp));
        dp[0][0] = true;
        for (int i = 0; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (j > 1 && p[j - 1] == '*') {
                    dp[i][j] = dp[i][j - 2] || (i > 0 && (s[i - 1] == p[j - 2] || p[j - 2] == '.') && dp[i - 1][j]);
                } else {
                    dp[i][j] = i > 0 && dp[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '.');
                }
            }
        }
        return dp[m][n];
    }
};