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;
                                        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()];
        }
};