LeetCode（10）：正则表达式匹配

Hard！

题目描述：

给定一个字符串 (s) 和一个字符模式 (p)。实现支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符。
'*' 匹配零个或多个前面的元素。

匹配应该覆盖整个字符串 (s) ，而不是部分字符串。

说明:

• s 可能为空，且只包含从 a-z 的小写字母。
• p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

示例 1:

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。

示例 2:

输入:
s = "aa"
p = "a*"
输出: true
解释: '*' 代表可匹配零个或多个前面的元素, 即可以匹配 'a' 。因此, 重复 'a' 一次, 字符串可变为 "aa"。

示例 3:

输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个('*')任意字符('.')。

示例 4:

输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 'c' 可以不被重复, 'a' 可以被重复一次。因此可以匹配字符串 "aab"。

示例 5:

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

解题思路：

这道题分的情况的要复杂一些，需要用递归Recursion来解：

- 若p为空，且s也为空，返回true，反之返回false

- 若p的长度为1，且s长度也为1，且相同或是p为'.'则返回true，反之返回false

- 若p的第二个字符不为*，且此时s为空则返回false，否则判断首字符是否匹配，且从各自的第二个字符开始调用递归函数匹配

- 若p的第二个字符为*，s不为空且字符匹配，调用递归函数匹配s和去掉前两个字符的p，若匹配返回true，否则s去掉首字母

- 返回调用递归函数匹配s和去掉前两个字符的p的结果

C++参考答案一：

 class Solution {
 public:
     bool isMatch(string s, string p) {
         if (p.empty()) return s.empty();
         if (p.size() == ) {
             return (s.size() ==  && (s[] == p[] || p[] == '.'));
         }
         if (p[] != '*') {
             if (s.empty()) return false;
             return (s[] == p[] || p[] == '.') && isMatch(s.substr(), p.substr());
         }
         while (!s.empty() && (s[] == p[] || p[] == '.')) {
             if (isMatch(s, p.substr())) return true;
             s = s.substr();
         }
         return isMatch(s, p.substr());
     }
 };

上面的方法可以写的更加简洁一些，但是整个思路还是一样的，我们先来判断p是否为空，若为空则根据s的为空的情况返回结果。当p的第二个字符为*号时，由于*号前面的字符的个数可以任意，可以为0，那么我们先用递归来调用为0的情况，就是直接把这两个字符去掉再比较，或者当s不为空，且第一个字符和p的第一个字符相同时，我们再对去掉首字符的s和p调用递归，注意p不能去掉首字符，因为*号前面的字符可以有无限个；如果第二个字符不为*号，那么我们就老老实实的比较第一个字符，然后对后面的字符串调用递归，参见代码如下：

C++参考答案二：

 class Solution {
 public:
     bool isMatch(string s, string p) {
         if (p.empty()) return s.empty();
         if (p.size() >  && p[] == '*') {
             return isMatch(s, p.substr()) || (!s.empty() && (s[] == p[] || p[] == '.') && isMatch(s.substr(), p));
         } else {
             return !s.empty() && (s[] == p[] || p[] == '.') && isMatch(s.substr(), p.substr());
         }
     }
 };

我们也可以用DP来解，定义一个二维的DP数组，其中dp[i][j]表示s[0,i)和p[0,j)是否match，然后有下面三种情况(下面部分摘自：https://leetcode.com/problems/regular-expression-matching/discuss/5684/9-lines-16ms-c-dp-solutions-with-explanations)：

1.  P[i][j] = P[i - 1][j - 1], if p[j - 1] != '*' && (s[i - 1] == p[j - 1] || p[j - 1] == '.');
2.  P[i][j] = P[i][j - 2], if p[j - 1] == '*' and the pattern repeats for 0 times;
3.  P[i][j] = P[i - 1][j] && (s[i - 1] == p[j - 2] || p[j - 2] == '.'), if p[j - 1] == '*' and the pattern repeats for at least 1 times.

 class Solution {
 public:
     bool isMatch(string s, string p) {
         int m = s.size(), n = p.size();
         vector<vector<bool>> dp(m + , vector<bool>(n + , false));
         dp[][] = true;
         for (int i = ; i <= m; ++i) {
             for (int j = ; j <= n; ++j) {
                 if (j >  && p[j - ] == '*') {
                     dp[i][j] = dp[i][j - ] || (i >  && (s[i - ] == p[j - ] || p[j - ] == '.') && dp[i - ][j]);
                 } else {
                     dp[i][j] = i >  && dp[i - ][j - ] && (s[i - ] == p[j - ] || p[j - ] == '.');
                 }
             }
         }
         return dp[m][n];
     }
 };