LeetCode第10题：正则表达式

实验报告恰好做到了这道题，由于要求当堂讲题，于是选择了这道题目来讲解，本文主要用来记叙自己做题和整理题目时的思路，供大家参考

题目描述

给你一个字符串 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 = “cab”
输出：true
解释：因为 ‘*’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。

示例 5：

输入：s = “mississippi” p = “misisp*.”
输出：false

提示：

0 <= s.length <= 20
0 <= p.length <= 30
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。
保证每次出现字符 * 时，前面都匹配到有效的字符

题目链接：

https://leetcode-cn.com/problems/regular-expression-matching

题目讲解

第一眼看上去该题要使用动态规划，接下来将分析具体的思路。

首先我们先建立一个 dp[m + 1][n + 1] 数组，dp[i][j]表示s[0：i]和p[0：j]是否能够匹配，m、n分别是字符串s和p的长度，之所以要+1是因为要给数组一个初始的值，即两个空串肯定是可以匹配的，dp[0][0] = true.

题目的要求就是两个字符串能够以一定的规则匹配，其中 s 字符串全是英文字符，p字符串含有英文字符和两个符号：‘ . ’和‘ * ’。
那么我们可以根据p中字符的种类将整个思路分成三种情况：

1. p[j] 为普通英文字符
2. p[j] 为‘.’
3. p[j] 为‘ * ’

1、p[j]为普通英文字符

这种是最一般的情况，假设此时 s 字符串走到了 i 位置，p 字符串走到了 j 位置，如下图：

在上图示例中，s[0：i] 和 p[0：j]能够匹配成功有两个条件：首先必须满足s[0: i-1]和p[0: j-1]是可以匹配成功的，其次要满足s[i]和p[j]是匹配成功的。
由此可以得出：

dp[i][j] = dp[i - 1][j - 1] && s[i] == p[j]

2、p[j]为‘ . ’

这种情况其实是上一种情况的特殊版，原因在于：’ . ‘可以匹配任意一个普通英文字符，两个重点：“ 任意 ” 和 “ 一个 ”，也就是说，当p[j]为’.‘时，无论s[i]为什么，在题目的规则下，永远满足s[i] == p[j]。示例如下：

根据规则，上图中满足：’ b ’ == ‘.’
由此可以得出:

dp[i][j] = dp[i-1][j-1]

3、p[j]为’ * ’

这种情况其实是最复杂的情况，’ * '可以代表非负数个前一个字符，我们并不知道代表多少个，这就是这种情况的复杂之处。·

我们先看上图的例子：根据肉眼观察，这时候，‘ * ’代表0个前一个字符，相当于“ a* ”这样一个整体相当于一个""字符串，即空字符串，相当于把“ a* ”在p字符串中消失了。

那么什么时候我们要考虑’ * '代表0个前一个字符呢？

很显然，如果s[i] 与 p[j-1] 不相等，那么就说明当前位置下，’ * ‘代表0个前一个字符。即：

s[i] != p[j-1] => dp[i][j] == dp[i][j-2]

那么s[i] == p[j]的时候，就要考虑’ * ‘代表非0个前一个字符的情况了，我们先看一个极端的例子：

这里的 ’ * ’ 代表多个’ e '，由于我们不知道具体代表多少个，那么这里我们就假设代表1个，假设的结果是什么呢？

对，让 i 左移一个单位，那么

dp[i][j] = dp[i - 1][j]。

左移之后，会再次遇到这种情况，从而再次左移，最后会出现下面的情况：

这种情况是不是似曾相识？
对，这种情况属于’ * '代表 0 个前一个字母的情况，正好就是我们之前讲过的s[i] != p[j-1]这种情况。此时：

dp[i][j] = dp[i][j-2]

也就是说，无论’ * ‘表示多少个前一个字母的情况，最后都会回到代表0个的情况。

综上所述，

p[j]是普通字符，则：
dp[i][j] = dp[i-1][j-1] && s[i]==p[j]
p[j]是’ . ‘，则：
dp[i][j] = dp[i-1][j-1]
p[j]是’ * '，则：
if s[i] == p[j-1]
dp[i][j] = dp[i][j-2] or dp[i-1][j]
if s[i] != p[j-1]
dp[i][j] = dp[i][j-2]
可以写出下列的状态转移方程：
$$dp[i][j]=\{\begin{array}{l}if（p[j]{\ne }^{\prime }{\ast }^{\prime }）=\{\begin{array}{ll}dp[i-1][j-1]，& \text{matches(s[i],p[j])}\\ false,& \text{otherwise}\end{array}\\ otherwise=\{\begin{array}{ll}dp[i-1][j]ordp[i][j-2]，& \text{matches(s[i],p[j-1])}\\ dp[i][j-2]，& \text{otherwise}\end{array}\end{array}$$

代码如下：

class Solution {
    public boolean isMatch(String s, String p) {
        int m = s.length();
        int n = p.length();

        boolean[][] dp = new boolean [m+1][n+1];
        dp[0][0] = true;
        for(int i = 0; i <= m; i++){
            for(int j = 1; j <= n; j++){
                if( p.charAt(j-1) == '*' ){
                    dp[i][j] = dp[i][j - 2];
                    if( ismatch(s,p,i,j-1) ){
                        dp[i][j] = dp[i][j] || dp[i-1][j];
                    }
                }else{
                    if( ismatch(s,p,i,j) ){
                        dp[i][j] = dp[i-1][j-1];
                    }
                }
            }
        }
        return dp[m][n];
    }
    public boolean ismatch(String s, String p, int i, int  j){
        if(i == 0){
            return false;
        }
        if( p.charAt(j-1) == '.' ){
            return true;
        }
        return s.charAt(i-1) == p.charAt(j-1);
    }
}