[leetcode] 10. 正则表达式匹配

原创已于 2024-03-07 17:36:10 修改 · 970 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #正则表达式 #算法 #java #数据结构

于 2024-01-16 19:24:05 首次发布

leetcode题解专栏收录该内容

71 篇文章

订阅专栏

文章讲述了如何使用Java编程语言实现支持`.`和`*`的正则表达式匹配，介绍了DFS遍历和动态规划两种方法，分别展示了相应的代码实现，同时分析了时间和空间复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

题目描述
解题方法
相似题目

题目描述

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

‘.’ 匹配任意单个字符
‘ $*$ ’ 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖整个字符串s的，而不是部分字符串。

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

示例 2:
输入：s = “aa”, p = “a $*$ ”
输出：true
解释：因为 ‘ $*$ ’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。

示例 3：
输入：s = “ab”, p = “. $*$ ”
输出：true
解释：“. $*$ ” 表示可匹配零个或多个（‘ $*$ ’）任意字符（‘.’）。

提示：
1 <= s.length <= 20
1 <= p.length <= 20
s 只包含从 a-z 的小写字母。
p 只包含从 a-z 的小写字母，以及字符 . 和 $*$ 。
保证每次出现字符 $*$ 时，前面都匹配到有效的字符

解题方法

方法一：dfs遍历

以下部分请结合代码进行理解。首先字符串s和字符串p转化为字符数组cs和cp，然后判断cs和cp是否符合规范，若不符合直接返回false；否则进行dfs遍历。

public boolean process(char[] s, char[] p, int si, int pi)方法就是dfs遍历方法，si代表从字符数组s的si索引位置开始匹配，pi代表从字符数组p的pi索引位置开始匹配。

下面介绍代码中的几种匹配情况。

当pi匹配到末尾时，如果si也匹配到末尾，则返回true；否则，返回false。
pi是最后一个字符位置或者 pi+1位置的字符不等于’ $*$ ‘时，如果si已经匹配到末尾，则返回false。否则，如果pi位置的字符不是’.‘并且pi位置的字符不等于si位置的字符，也返回fasle；如果pi的位置是’.'或者 pi位置的字符等于si位置的字符，需要再比较从si+1位置和pi+1位置开始的后续字符。
如果pi不是最后一个字符位置，并且pi+1位置的字符等于’ $*$ '时，设pi位置的字符为 $c$ ，’ $c *$ '代表我们可以匹配0到多个 $c$ 。我们先认为字符数组s匹配了0个 $c$ ，si的位置不变，pi的位置往后移动2位，进行后续的dfs遍历，如果后续遍历结果为true，代表从si和pi位置开始的遍历结果为true；否则，我们先认为’ $c *$ '匹配字符数组s一个 $c$ ，此时如果pi位置的字符等于‘.'或者pi位置的字符和si位置的字符相等，si往后移动一位，遍历si和pi+2位置的后续字符，如果结果为true，代表从原si（si未加1）和pi位置开始的遍历结果为true；否则，我们再认为’ $c *$ '匹配字符数组s两个 $c$ …依次类推，直到si匹配到字符末尾。

java代码

public class Solution {
    public boolean isVaild(char[] s, char[] p) {
        for (int i = 0; i < s.length; i++) {
            if (!(s[i] >= 'a' && s[i] <= 'z')) {
                return false;
            }
        }
        for (int i = 0; i < p.length; i++) {
            if ((p[i] >= 'a' && p[i] <= 'z') || p[i] == '.' || p[i] == '*') {
                if (p[i] == '*' && i == 0) {
                    return false;
                }
            } else {
                return false;
            }
        }
        return true;
    }

    public boolean process(char[] s, char[] p, int si, int pi) {
        // pi匹配到末尾时
        if (pi == p.length) {
            return si == s.length;
        }
        // pi是最后一个字符位置 或者 pi+1位置的字符不等于'*'
        if (pi == p.length - 1 || p[pi + 1] != '*') {
            // si匹配完了 或者 （pi位置的字符不是'.'并且pi位置的字符不等于si位置的字符）
            if (si == s.length || (p[pi] != '.' && p[pi] != s[si])) {
                return false;
            }
            // pi的位置是'.' 或者 pi位置的字符等于si位置的字符
            return process(s, p, si + 1, pi + 1);
        }
        // 设pi位置的字符为c，pi+1位置的字符为'*'，process为true时，认为匹配了0个c；process为false时，认为匹配了1...n个c
        if (!process(s, p, si, pi + 2)) {
            // pi位置的字符为'.' 或者 si位置的字符等于pi位置的字符。每次si++，代表匹配了一个c
            while (si < s.length && (p[pi] == '.' || s[si] == p[pi])) {
                si++;
                if (process(s, p, si, pi + 2)) {
                    return true;
                }
            }
            return false;
        }
        return true;
    }

    public boolean isMatch(String s, String p) {
        if (s == null || p == null) {
            return false;
        }
        char[] cs = s.toCharArray();
        char[] cp = p.toCharArray();
        if (!isVaild(cs, cp)) {
            return false;
        }
        return process(cs, cp, 0, 0);
    }
}

时间复杂度： $O(M^2N^2)$ ， $M$ 为字符串s的长度， $N$ 为匹配模式p的长度
空间复杂度： $O (MN)$ ，空间复杂度取决于递归调用栈的深度，最坏情况下的递归调用深度为 $\times N$ 。

方法二：动态规划

实际上就是用dp数组存储dfs状态，dp[si][pi]代表从si和pi位置开始遍历的字符串匹配结果。si=s.length且pi=p.length时，代表从s和p的末尾开始匹配，此时dp[si][pi]=true，因为没有需要匹配的字符。我们需要求的是dp[0][0]，代表si和pi从下标0的索引位置返回的匹配结果。

java代码

public class Solution {
    public boolean isValid(char[] s, char[] p) {
        for (int i = 0; i < s.length; i++) {
            if (!(s[i] >= 'a' && s[i] <= 'z')) {
                return false;
            }
        }
        for (int i = 0; i < p.length; i++) {
            if ((p[i] >= 'a' && p[i] <= 'z') || p[i] == '.' || p[i] == '*') {
                if (p[i] == '*' && i == 0) {
                    return false;
                }
            } else {
                return false;
            }
        }
        return true;
    }

    public boolean isMatch(String str, String exp) {
        if (str == null || exp == null) {
            return false;
        }
        char[] s = str.toCharArray();
        char[] e = exp.toCharArray();
        if (!isValid(s, e)) {
            return false;
        }
        boolean[][] dp = initDPMap(s, e);
        for (int i = s.length - 1; i > -1; i--) {
            for (int j = e.length - 2; j > -1; j--) {
                if (e[j + 1] != '*') {
                    dp[i][j] = (s[i] == e[j] || e[j] == '.')
                            && dp[i + 1][j + 1];
                } else {
                    int si = i;
                    while (si != s.length && (s[si] == e[j] || e[j] == '.')) {
                        if (dp[si][j + 2]) {
                            dp[i][j] = true;
                            break;
                        }
                        si++;
                    }
                    if (dp[i][j] != true) {
                        dp[i][j] = dp[si][j + 2];
                    }
                }
            }
        }
        return dp[0][0];
    }

    public boolean[][] initDPMap(char[] s, char[] e) {
        int slen = s.length;
        int elen = e.length;
        boolean[][] dp = new boolean[slen + 1][elen + 1];
        dp[slen][elen] = true;
        for (int j = elen - 2; j > -1; j = j - 2) {
            if (e[j] != '*' && e[j + 1] == '*') {
                dp[slen][j] = true;
            } else {
                break;
            }
        }
        if (slen > 0 && elen > 0) {
            if ((e[elen - 1] == '.' || s[slen - 1] == e[elen - 1])) {
                dp[slen - 1][elen - 1] = true;
            }
        }
        return dp;
    }
}