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