Regular Expression Matching

Recursive Solution

class Solution {
public:
bool isMatch(string s, string p) {
if (p.empty())    return s.empty();

if ('*' == p[1])
// x* matches empty string or at least one character: x* -> xx*
// *s is to ensure s is non-empty
return (isMatch(s, p.substr(2)) || !s.empty() && (s[0] == p[0] || '.' == p[0]) && isMatch(s.substr(1), p));
else
return !s.empty() && (s[0] == p[0] || '.' == p[0]) && isMatch(s.substr(1), p.substr(1));
}
};

DP Solution

class Solution {
public:
bool isMatch(string s, string p) {
/**
* f[i][j]: if s[0..i-1] matches p[0..j-1]
* if p[j - 1] != '*'
*      f[i][j] = f[i - 1][j - 1] && s[i - 1] == p[j - 1]
* if p[j - 1] == '*', denote p[j - 2] with x
*      f[i][j] is true iff any of the following is true
*      1) "x*" repeats 0 time and matches empty: f[i][j - 2]
*      2) "x*" repeats >= 1 times and matches "x*x": s[i - 1] == x && f[i - 1][j]
* '.' matches any single character
*/
int m = s.size(), n = p.size();
vector<vector<bool>> f(m + 1, vector<bool>(n + 1, false));

f[0][0] = true;
for (int i = 1; i <= m; i++)
f[i][0] = false;
// p[0.., j - 3, j - 2, j - 1] matches empty iff p[j - 1] is '*' and p[0..j - 3] matches empty
for (int j = 1; j <= n; j++)
f[0][j] = j > 1 && '*' == p[j - 1] && f[0][j - 2];

for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (p[j - 1] != '*')
f[i][j] = f[i - 1][j - 1] && (s[i - 1] == p[j - 1] || '.' == p[j - 1]);
else
// p[0] cannot be '*' so no need to check "j > 1" here
f[i][j] = f[i][j - 2] || (s[i - 1] == p[j - 2] || '.' == p[j - 2]) && f[i - 1][j];

return f[m]
;
}
};

To be honest, this algorithm bothers me for a very long time cause I simply don’t get it. Here is the explanation:

Consider s and p are presented as follows:

s:s0,s1,s2,...,si−2,si−1 p:p0,p1,p2,...,pj−2,pj−1

1. If pj−1 is not *, like this:

s:s0,s1,s2,...,si−2,si−1 p:p0,p1,p2,...,pj−2,a

then the only way f[i][j] can be true is that: s0,s1,s2,...,si−2 matches p0,p1,p2,...,pj−2 as well as si−1 matches pj−1.

2. If pj−1 is *, like this:

s:s0,s1,s2,...,si−2,si−1 p:p0,p1,p2,...,a,∗

then the only way f[i][j] can be true is that:

– For any length of s, it is equal to p0,p1,p2,...,pj−3, which means a,∗ will not appear in s.

– For string s0,s1,s2,...,si−2, it is equal to p0,p1,p2,...,pj−2,pj−1, and any character after si−2, it is a match of the character before *