46：Regular Expression Matching

题目：Implement regular expression matching with support for ‘.’ and ‘*’.

‘.’ Matches any single character. ‘*’ Matches zero or more of the preceding element.

The matching should cover the entire input string (not partial).

The function prototype should be:

bool isMatch(const char *s, const char *p)

Some examples:

isMatch(“aa”,”a”) → false

isMatch(“aa”,”aa”) → true

isMatch(“aaa”,”aa”) → false

isMatch(“aa”, “a*”) → true

isMatch(“aa”, “.*”) → true

isMatch(“ab”, “.*”) → true

isMatch(“aab”, “c*a*b”) → true

解析1：递归算法，代码如下：

// 递归版
// 注意，字符串 s 不包含 '.' 和 '*'
// 字符串 p 才包含 '.' 和 '*'
// 并且还要注意的是字符串 p 的第一个字符为 '*'时是毫无意义的
class Solution {
public:
bool isMatch1(string s, string p) {
return isMatch(s.c_str(), p.c_str());
}
private:
bool isMatch(const char* s, const char* p) {
if (*p == '\0') return *s == '\0';
else if (*p == '*') return isMatch(s, p + 1);
// next char is not '*', then must match current character
if (*(p + 1) != '*') {
if (*p == *s || (*p == '.' && *s != '\0'))
return isMatch(s + 1, p + 1);
else
return false;
}
else { // next char is '*'
while (*p == *s || (*p == '.'  && *s != '\0')) {
if (isMatch(s, p + 2)) return true;
++s;
}
return isMatch(s, p + 2);
}
}
};

该递归算法最差的时间复杂度为指数级，对应的例子可以为 s: aa…ab， p : a*a*…a*。为了避免这种情况的出现，可以采用动态规划算法，其时间复杂度为O(n^2)；

解析2：动态规划算法，详情见博客http://blog.csdn.net/linhuanmars/article/details/21145563

代码如下：

//动态规划算法
//时间复杂度O(n^2)，空间复杂度O(n^2)
// 注意，字符串 s 不包含 '.' 和 '*'
// 字符串 p 才包含 '.' 和 '*'
// 字符串 p 的第一个字符为 '*'时是毫无意义的
class Solution {
public:
bool isMatch(string s, string p) {
if (s.size() == 0 && p.size() == 0)
return true;
if (p.size() == 0) return false;

// 根据算法定义，table[0][0] 应为 true
// 并且 table[1...N][0] 应为 false
bool table[s.size() + 1][p.size() + 1];
for (int i = 0; i != s.size() + 1; ++i)
for (int j = 0; j != p.size() + 1; ++j)
table[i][j] = false;
table[0][0] = true;

// 接下来对 table 中的其它元素进行计算
for (int j = 0; j < p.size(); ++j) {
if (p[j] == '*') {
if (j == 0) continue;
if (j > 0 && table[0][j - 1]) table[0][j + 1] = true;
if (p[j - 1] != '.') {
for (int i = 0; i != s.size(); ++i) {
if (table[i + 1][j] || table[i + 1][j - 1] || i > 0 && table[i][j + 1] &&
s[i] == s[i - 1] && s[i - 1] == p[j - 1])
table[i + 1][j + 1] = true;
}
}
else {
int i = 0;
while (i < s.size() && !table[i + 1][j - 1] && !table[i + 1][j])
++i;

4000
for ( ; i < s.size(); ++i)
table[i + 1][j + 1] = true;
}
}
else {
for (int i = 0; i < s.size(); ++i)
if (s[i] == p[j] || p[j] == '.')
table[i + 1][j + 1] = table[i][j];
}
}

return table[s.size()][p.size()];
}
};