leetcode：10. 正则表达式匹配

OceanStar的学习笔记

已于 2022-08-12 14:13:25 修改

阅读量358

点赞数

分类专栏：算法与数据结构文章标签： leetcode 动态规划算法

于 2022-05-06 21:53:24 首次发布

原文链接：https://leetcode-cn.com/problems/regular-expression-matching/

版权

算法与数据结构专栏收录该内容

1135 篇文章 84 订阅

订阅专栏

题目来源

leetcode

题目描述

在这里插入图片描述

class Solution {
public:
    bool isMatch(string s, string p) {
    
    }
};

题目解析

分析题意

str中一定不能含有.，*
exp中：
- .可以匹配任意一个字符
- *：必须和exp前一个字符绑定使用（前一个字符可以是.）
  - 可以消除前面的那个符号
  - 可以什么也不干
  - 可以复制任意次前面的个符号（1次，2次，3次）
- 因此exp中不能出现连续的两个*

在这里插入图片描述

因此，在匹配开始之前

先做一个大的过滤：

str中一定不能含有.，*
exp中不能出现连续的两个*

匹配是可以从前往后扫描，也可以从后往前扫描

（1）从前往后扫描的话：字符后面是否跟着*会影响结果，分析起来比较复杂
在这里插入图片描述
（2）从后往前扫描的话

*的前面一定有一个字符，*也只影响这一个字符，它就像一个拷贝器

在这里插入图片描述

s、p 串是否匹配，取决于：最右端是否匹配、剩余的子串是否匹配。
只是最右端可能是特殊符号，需要分情况讨论而已

样本对应模型

定义dp[si][ei]：str[si......]能不能被exp[ei...]匹配出来

base case：

当exp没有了，str也必须没有了才是对得上
当exp没有了，但是str还有没有匹配上的，那么就返回false

普通情况：

expr有，str没有
expr有，str有

怎么决策普通情况呢？根据ei的下一个位置是不是*来决策

如果 $e i + 1$ 不是*
- $e i + 1$ 不是*有哪些情况呢？
  - $e i + 1 == e . l e n$ ，说明 $e i$ 和 $s i$ 是最后的字符了
  - $e [e i + 1]! = *$
- 怎么决策？
  - 如果 $e i + 1$ 不是*，就说明 $e i$ 没有操作空间了，就是说后面没有*可以将 $e i$ 变没
  - 此时 $s i$ 必须能和 $e i$ 对上。这意味着：
    - $s i! = s . l e n$
    - 而且，下面情况之一必须成立：
      - $e [e i] == s [s i]$
      - $e [e i] == .$
  - 然后对继续下一个字符匹配： $s [s i + 1] 与 e [e i + 1]$
如果 $e i + 1$ 是*，那么可以使用*对 $e [e i]$ 消除，复制、什么也不干
- 如果 $e [e i]! = s [s i]$ ，那么必须用 *将 $e [e i]$ 消除，因此，下一步 $s [s i]$ 和 $e [e i + 2]$ 匹配
- 如果 $e [e i] == s [s i]$ ，那么可以用来消除零个或者一个或者全部的 $s [s i]$

class Solution {
    bool isValid(string s, string e){
        // s中不能有'.' or '*'
        for (int i = 0; i < s.size(); ++i) {
            if(s[i] == '.' || s[i] == '*'){
                return false;
            }
        }

        // 开头的e[0]不能是'*'，没有相邻的'*'
        for (int i = 0; i < e.size(); ++i) {
            if(e[i] == '*' && (i == 0 || e[i - 1] == '*')){
                return false;
            }
        }
        return true;
    }
    // str[si.....] 能不能被 exp[ei.....]配出来！ true false
    bool process(string s, string e, int si, int ei){
        if(ei == e.length()){
            return si == s.length();
        }

        // exp[ei]还有字符
        // ei + 1位置的字符，不是*
        if(ei + 1 == e.length() || e[ei + 1] != '*'){
            // ei + 1 不是*
            // str[si] 必须和 exp[ei] 能配上！
            return si != s.length() && (e[ei] == s[si] || e[ei] == '.') && process(s, e, si + 1, ei + 1);
        }

        // exp[ei]还有字符
        // ei + 1位置的字符，是*
        while (si != s.length() && (e[ei] == s[si] || e[ei] == '.')) {
            if (process(s, e, si, ei + 2)) {
                return true;
            }
            si++;
        }
        
        return process(s, e, si, ei + 2);
    }
public:
    bool isMatch(string s, string e) {
        if(e.empty() || e.empty()){
            return false;
        }
        
        return isValid(s, e) && process(s, e, 0, 0);
    }
};

记忆化搜索


class Solution {
    bool isValid(string s, string e){
        // s中不能有'.' or '*'
        for (int i = 0; i < s.size(); ++i) {
            if(s[i] == '.' || s[i] == '*'){
                return false;
            }
        }

        // 开头的e[0]不能是'*'，没有相邻的'*'
        for (int i = 0; i < e.size(); ++i) {
            if(e[i] == '*' && (i == 0 || e[i - 1] == '*')){
                return false;
            }
        }
        return true;
    }
    // str[si.....] 能不能被 exp[ei.....]配出来！ true false
    bool process(string s, string e, int si, int ei, std::vector<std::vector<int>> &dp){
        if (dp[si][ei] != 0) {
            return dp[si][ei] == 1;
        }
        
        bool ans = false;
        if(ei == e.length()){
            ans = si == s.length();
        }else{
            // exp[ei]还有字符
            // ei + 1位置的字符，不是*
            if(ei + 1 == e.length() || e[ei + 1] != '*'){
                // ei + 1 不是*
                // str[si] 必须和 exp[ei] 能配上！
                ans =  si != s.length() && (e[ei] == s[si] || e[ei] == '.') && process(s, e, si + 1, ei + 1);
            }else{
                if(si == s.length()){
                    ans = process(s, e, si, ei + 2, dp);
                }else{  // si没结束
                    if (s[si] != e[ei] && e[ei] != '.') {
                        ans = process(s, e, si, ei + 2, dp);
                    } else { // s[si] 可以和 e[ei]配上
                        ans = process(s, e, si, ei + 2, dp) || process(s, e, si + 1, ei, dp);
                    }
                }
            }
        }

        dp[si][ei] = ans ? 1 : -1;
        return ans;
    }
public:
    bool isMatch(string s, string e) {
        if(e.empty() || e.empty()){
            return false;
        }
        
        std::vector<std::vector<int>> dp(s.length() + 1, std::vector<int>(e.length() + 1));
        // dp[i][j] = 0, 没算过！
        // dp[i][j] = -1 算过，返回值是false
        // dp[i][j] = 1 算过，返回值是true
        return isValid(s, e) && process(s, e, 0, 0, dp);
    }
};