点击 这里 能够查看更多算法面试相干内容~

题目形容

给你一个字符串 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
解释：".*" 示意可匹配零个或多个（'*'）任意字符（'.'）。

示例 4：

 输出：s = "aab" p = "c*a*b"
输入：true
解释：因为 '*' 示意零个或多个，这里 'c' 为 0 个, 'a' 被反复一次。因而能够匹配字符串 "aab"。

示例 5：

 输出：s = "mississippi" p = "mis*is*p*." 
输入：false

提醒：

• 0 <= s.length <= 20
• 0 <= p.length <= 30
• s 可能为空，且只蕴含从 a-z 的小写字母。
• p 可能为空，且只蕴含从 a-z 的小写字母，以及字符 . 和 *。
• 保障每次呈现字符 * 时，后面都匹配到无效的字符

动静布局解法

整顿一下题意，对于字符串 p 而言，有三种字符：

• 一般字符：须要和 s 中同一地位的字符齐全匹配
• '.'：可能匹配 s 中同一地位的任意字符
• '*'：不可能独自应用 '*'，必须和前一个字符同时搭配应用，数据保障了 '*' 可能找到后面一个字符。可能匹配 s 中同一地位字符任意次。

所以本题要害是剖析当呈现 a* 这种字符时，是匹配 0 个 a、还是 1 个 a、还是 2 个 a …

本题能够应用动静布局进行求解：

• 状态定义：f(i,j) 代表思考 s 中以 i 为结尾的子串和 p 中的 j 为结尾的子串是否匹配。即最终咱们要求的后果为 f[n][m]。

• 状态转移：也就是咱们要思考 f(i,j) 如何求得，后面说到了 p 有三种字符，所以这里的状态转移也要分三种状况探讨：

  1. p[j] 为一般字符：匹配的条件是后面的字符匹配，同时 s 中的第 i 个字符和 p 中的第 j 位雷同。即 f(i,j) = f(i - 1, j - 1) && s[i] == p[j]。
  2. p[j] 为 '.'：匹配的条件是后面的字符匹配，s 中的第 i 个字符能够是任意字符。即 f(i,j) = f(i - 1, j - 1) && p[j] == '.'。
  3. p[j] 为 '*'：读得 p[j - 1] 的字符，例如为字符 a。而后依据 a* 理论匹配 s 中 a 的个数是 0 个、1 个、2 个 …

     3.1. 当匹配为 0 个：f(i,j) = f(i, j - 2)

     3.2. 当匹配为 1 个：f(i,j) = f(i - 1, j - 2) && (s[i] == p[j - 1] || p[j - 1] == '.')

     3.3. 当匹配为 2 个：f(i,j) = f(i - 2, j - 2) && ((s[i] == p[j - 1] && s[i - 1] == p[j - 1]) || p[j] == '.')

     …
     

所有的状态转移都搞清楚之后，就能够写代码啦：

class Solution {public boolean isMatch(String ss, String pp) {// 技巧：往原字符头部插入空格，这样失去 char 数组是从 1 开始，而且能够使得 f[0][0] = true，能够将 true 这个后果滚动上来
        int n = ss.length(), m = pp.length();
        ss = " " + ss;
        pp = " " + pp;
        char[] s = ss.toCharArray();
        char[] p = pp.toCharArray();
        // f(i,j) 代表思考 s 中的 1~i 字符和 p 中的 1~j 字符 是否匹配
        boolean[][] f = new boolean[n + 1][m + 1];
        f[0][0] = true;
        for (int i = 0; i <= n; i++) {for (int j = 1; j <= m; j++) {
                // 如果下一个字符是 '*'，则代表以后字符不能被独自应用，跳过
                if (j + 1 <= m && p[j + 1] == '*') continue;
                
                // 对应了 p[j] 为一般字符和 '.' 的两种状况
                if (i - 1 >= 0 && p[j] != '*') {f[i][j] = f[i - 1][j - 1] && (s[i] == p[j] || p[j] == '.');
                } 
                
                // 对应了 p[j] 为 '*' 的状况
                else if (p[j] == '*') {f[i][j] = (j - 2 >= 0 && f[i][j - 2]) || (i - 1 >= 0 && f[i - 1][j] && (s[i] == p[j - 1] || p[j - 1] == '.'));
                }
            }
        }
        return f[n][m];
    }
}

工夫复杂度：n 示意 s 的长度，m 示意 p 的长度，总共 n * m 个状态。复杂度为 $O(n * m)$

空间复杂度：应用了二维数组记录后果。复杂度为 $O(n * m)$

动静布局实质上是枚举（不反复的暴力枚举），因而其复杂度很好剖析，有多少个状态就要被计算多少次，复杂度就为多少。

最初

这是咱们「刷穿 LeetCode」系列文章的第 No.10 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，局部是有锁题，咱们将先将所有不带锁的题目刷完。

在这个系列文章外面，除了解说解题思路以外，还会尽可能给出最为简洁的代码。如果波及通解还会相应的代码模板。

因为 LeetCode 的题目随着周赛 & 双周赛一直减少，为了不便咱们统计进度，咱们将依照系列起始时的总题数作为分母，实现的题目作为分子，进行进度计算。以后进度为 10/1916。

为了不便各位同学可能电脑上进行调试和提交代码，我建设了相干的仓库：Github 地址 & Gitee 地址。

在仓库地址里，你能够看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和一些其余的优选题解。

算法与数据结构

LeetCode 题解

算法面试