Leetcode10 正则表达式匹配

最新推荐文章于 2022-12-11 22:55:52 发布

alpaca_ll

最新推荐文章于 2022-12-11 22:55:52 发布

阅读量484

点赞数

分类专栏： Leetcode刷题笔记文章标签： leetcode 算法

原文链接：https://leetcode-cn.com/problems/regular-expression-matching/solution/dong-tai-gui-hua-zen-yao-cong-0kai-shi-si-kao-da-b/

版权

Leetcode刷题笔记专栏收录该内容

18 篇文章 1 订阅

订阅专栏

本题为Leetcode上的困难题，给出了别人相应的题解，供自己和相关爱好者参考学习。

题目描述

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

示例 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

//方法1 递归回溯
递推关系：
class Solution {
public:
    bool isMatch(string s, string p) {
        //方法1 递归回溯
        if(p.empty())   return s.empty();
        bool firstMatch = (!s.empty() && (s[0] == p[0] || p[0] == '.'));
        // 从p的第2个字符开始，如果为 '*'
        if (p.size() >= 2 && p[1] == '*')       //第二个字符为*
            //当第一个字符不匹配时，p串的前两个字符可以被忽略
            //因此p需要分离前两个字符进行遍历，即isMatch(s, p.substr(2))
            //当第一个字符匹配时，表示p串的前两个字符与s的第一个字符匹配
            //而p串又可以表示第一个字符出现了多次，需要重新与后续序列匹配
            //因此s需要分离第一个字符再进行遍历，即firstMatch && isMatch(s.substr(1), p)
            return (isMatch(s, p.substr(2)) || (firstMatch && isMatch(s.substr(1), p)));
        else
            return firstMatch && isMatch(s.substr(1), p.substr(1));
    }
};

上述的递归代码看似容易，实则难以理解，而本题还可以用动态规划进行解决，以下是来自别人的题解思路：

1. 状态

首先状态dp一定能自己想出来,dp[i][j]表示s的前i个是否能够被p的前j个匹配。

2. 转移方程

怎么想转移方程？首先想的时候从已经求出了 dp[i-1][j-1] 入手，再加上已知 s[i]、p[j]，要想的问题就是怎么去求 dp[i][j]。

已知 dp[i-1][j-1] 意思就是前面子串都匹配上了，不知道新的一位的情况。
那就分情况考虑，所以对于新的一位 p[j] s[i] 的值不同，要分情况讨论：

（1）考虑最简单的 p[j] == s[i] : dp[i][j] = dp[i-1][j-1]，然后从 p[j] 可能的情况来考虑，让 p[j]=各种能等于的东西。

（2）p[j] == "." : dp[i][j] = dp[i-1][j-1]

（3）p[j] ==" * ":

第一个难想出来的点：怎么区分 ∗*∗ 的两种讨论情况

首先给了 *，明白 * 的含义是匹配零个或多个前面的那一个元素，所以要考虑他前面的元素 p[j-1]。* 跟着他前一个字符走，前一个能匹配上 s[i]，* 才能有用，前一个都不能匹配上 s[i]，* 也无能为力，只能让前一个字符消失，也就是匹配 000 次前一个字符。所以按照 p[j-1] 和 s[i] 是否相等，我们分为两种情况：

（1）p[j-1] != s[i] : dp[i][j] = dp[i][j-2]

这就是刚才说的那种前一个字符匹配不上的情况。比如(ab, abc * )。遇到 * 往前看两个，发现前面 s[i] 的 ab 对 p[j-2] 的 ab 能匹配，虽然后面是 c*，但是可以看做匹配 000 次 c，相当于直接去掉 c *，所以也是 True。注意 (ab, abc**) 是 False。

（2）p[j-1] == s[i] or p[j-1] == "."：

* 前面那个字符，能匹配 s[i]，或者 * 前面那个字符是万能的 .
因为 . * 就相当于 . .，那就只要看前面可不可以匹配就行。
比如 (##b , ###b *)，或者 ( ##b , ### . * ) 只看 ### 后面一定是能够匹配上的。
所以要看 b 和 b * 前面那部分 ## 的地方匹不匹配。

第二个难想出来的点：怎么判断前面是否匹配

dp[i][j] = dp[i-1][j] // 多个字符匹配的情况
or dp[i][j] = dp[i][j-1] // 单个字符匹配的情况
or dp[i][j] = dp[i][j-2] // 没有匹配的情况

看 ### 匹不匹配，不是直接只看 ### 匹不匹配，要综合后面的 b b* 来分析。这三种情况是 ororor 的关系，满足任意一种都可以匹配上，同时是最难以理解的地方：

dp[i-1][j] 就是看 s 里 b 多不多， ### 和 ###b * 是否匹配，一旦匹配，s 后面再添个 b 也不影响，因为有 * 在，也就是 ###b 和 ###b *也会匹配。

dp[i][j-1] 就是去掉 * 的那部分，###b 和 ###b 是否匹配，比如 qqb qqb

dp[i][j-2] 就是去掉多余的 b *，p 本身之前的能否匹配，###b 和 ### 是否匹配，比如 qqb qqbb* 之前的 qqb qqb 就可以匹配，那多了的 b * 也无所谓，因为 b * 可以是匹配 000 次 b，相当于 b * 可以直接去掉了。

三种满足一种就能匹配上。为什么没有 dp[i-1][j-2] 的情况？就是 ### 和 ### 是否匹配？因为这种情况已经是 dp[i][j-1] 的子问题。也就是 s[i]==p[j-1]，则 dp[i-1][j-2]=dp[i][j-1]。

总结

        如果 p.charAt(j) == s.charAt(i) : dp[i][j] = dp[i-1][j-1]；
        如果 p.charAt(j) == '.' : dp[i][j] = dp[i-1][j-1]；
        如果 p.charAt(j) == '*'：

    如果 p.charAt(j-1) != s.charAt(i) : dp[i][j] = dp[i][j-2] //in this case, a* only counts as empty
           如果 p.charAt(i-1) == s.charAt(i) or p.charAt(i-1) == '.'：
       dp[i][j] = dp[i-1][j] //in this case, a* counts as multiple a
                   or dp[i][j] = dp[i][j-1] // in this case, a* counts as single a
                   or dp[i][j] = dp[i][j-2] // in this case, a* counts as empty

class Solution {
public:
    bool isMatch(string s, string p) {
        if (p.empty())  return s.empty();
        // 前面加某一相同字符，
        // 防止 (ab, c*ab) 这样的匹配，
        // 避免复杂的初始化操作
        s = " " + s;
        p = " " + p;
        int m = s.size(), n = p.size();
        // 定义记忆数组，并初始化为false
        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1, false));
        // 设添加的字符为真
        dp[0][0] = true;
        // 记忆数组能保持字符串上一个字符的状态
        // 因此可以对下一个字符进行判断
        for (int i = 1; i < m + 1; i++) {
            for (int j = 1; j < n + 1; j++) {
                // 不带 '*' 号时的匹配
                if (s[i - 1] == p[j - 1] || p[j - 1] == '.') 
                    dp[i][j] = dp[i - 1][j - 1];
                else if (p[j - 1] == '*') {
                    // 考虑 '*' 时的两种情况
                    if (s[i - 1] != p[j - 2] && p[j - 2] != '.')
                        dp[i][j] = dp[i][j - 2];
                    else
                        dp[i][j] = dp[i][j - 2] || dp[i - 1][j];
                }
            }
        }
        // 返回最后字符的匹配状态
        return dp[m][n];
    }
};