[动态规划] leetcode 10 正则表达式匹配

[动态规划] leetcode 10 正则表达式匹配

1.题目

题目链接
给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

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

所谓匹配，是要涵盖整个字符串 s的，而不是部分字符串。
说明：

• 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

2.分析

2.1.过程分析

先考虑模式串p。p的匹配可以分为三种情况：

• 只取p的一个字符(a~z)；
• 只取p的一个字符(.)；
• 取p的一个字符与其之后的* 。

情况1、2具有唯一性(只取一个字符)，而情况3是不唯一的(可以取0至若干个字符)，因此当遍历到p的第j个字符p[j]时会有多种选择，这就意味着本题变成了一个搜索问题。

2.2.状态定义

由于涉及到两个字符串，那么dp数组大概率是二维的，一维用于记录s的状态，另一维用于记录p的状态。而需要记录的"状态"则是匹配成功与否。
记dp[i][j]表示s的前i个字符与p的前j个字符能否匹配，那么最后得到的dp[m][n](m、n分别为s、p的长度)便为要求的结果。

2.3.状态转移

考虑2.1节中的情况1。如果p[j]为a~z，有：
$$dp[i][j]=\{\begin{array}{l}dp[i-1][j-1]s[i]=p[j]\\ falses[i]\ne p[j]\end{array}$$
也就是说，如果s[i] != p[j]，则直接匹配失败，dp[i][j] = 0；如果s[i] = p[j]，则要视dp[i-1][j-1]的结果。

考虑2.2节中的情况2。如果p[j]为.，由于.可以匹配任意字符，有：
$$dp[i][j]=dp[i-1][j-1]$$
定义match(s[i], p[j])为s[i]与p[j]能否匹配，此时可以将情况1与情况2合并，有：
$$dp[i][j]=\{\begin{array}{l}dp[i-1][j-1]match(s[i],p[j])\\ falseotherwise\end{array}$$

考虑2.3节中的情况3，如果p[j]为* ，由于*要配合其之前的一个字符才能起作用，因此我们实际上需要关注的是p[j-1]与s[i]能否匹配，有
$$dp[i][j]=\{\begin{array}{l}dp[i-1][j]ordp[i][j-2]match(s[i],p[j-1])\\ dp[i][j-2]otherwise\end{array}$$
如果不能匹配：此时为了尽可能匹配，只能令 * 表示零个元素以跳过匹配失败的p[j-1]，此时dp[i][j] = dp[i][j-2]。
如果能够匹配：首先同样可以放弃匹配成功的p[j-1]，便获取了一种可能选择dp[i][j-2]；而如果不放弃，此时我们至少需要匹配s中的一个字符。那么如何表示匹配一个或多个呢？
答案是使用dp[i-1][j]。由于i是从小到大遍历的，实际上dp[i-1]记载了s[i-1]、s[i-2]、…、s[0]是否能成功匹配的信息，因此直接使用dp[i-1]即可。

3.代码

class Solution {
public:
    bool match(int i, int j, string s, string p) {
        if (i == 0) {
            return false;
        }
        if (p[j - 1] == '.') {
            return true;
        }
        return s[i - 1] == p[j - 1];
    };

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