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）确定边界的值
2）动态规划推导方程
http://blog.csdn.net/fzzying3/article/details/42057935
这里我们对该动态规划解法进行一定的分析说明，
这里我们采用b[i+1][j+1]代表s[0..i]匹配p[0..j]的结果，结果自然是采用布尔值True/False来表示。
1.因此，首先是对边界进行赋值，显然b[0][0] = true，两个空字符串的匹配结果自然为True
接下来，我们对b[i+1][0]进行赋值，显然对于空的匹配串，b[i+1][0]的数值必须为False
接着，我们对b[0][j+1]进行赋值，其值等于j > 0 && '*' == p[j] && b[0][j - 1]，
1.首先是j>0，原因很简单，如果j=0则b[0][1]表示空的原串匹配长度为1的匹配串，无论长度为1的匹配串
为何种字符串，其结果都为false，试想一下，如果匹配串为一个字母字符自不必多说，如果为"."也容易理解，
如果为“*”，则是无效字符串，因为本题要求"*"之前必须要有一个字符，所以长度为1的字符串不可能为“*”；
2.其次'*' == p[j] && b[0][j - 1]，如果一个空串和一个匹配串想要匹配成功，那么只有可能是：
p[0..j-2]匹配空串成功且无论p[j-1]是什么p[j]都必须是'*'，所以就是'*' == p[j] && b[0][j - 1]
前两个边界赋值结束了之后，接下来就是经典的动态规划递推方程了：
1. 当前匹配串的字符不为’*‘，那么b[i + 1][j + 1] = b[i][j] && ('.' == p[j] || s[i] == p[j])，显然如果当前字符串不为'*'，
则我们需要实打实地对s[i]和p[j]进行匹配，因此很自然s[0..i]和p[0..j]的匹配结果取决于s[0..i-1]和p[0..j-1]的
匹配结果与上s[i]和p[j]的匹配结果，因此就造就了上式；
2.若当前匹配串的字符为’*‘，那么b[i + 1][j + 1] = b[i + 1][j - 1] && j > 0 || b[i + 1][j]
|| b[i][j + 1] && j > 0 && ('.' == p[j - 1] || s[i] == p[j - 1]);
其意义为s[0..i]和p[0..j]的匹配结果取决于s[0..i]和p[0..j-2]的匹配结果，意味着我们忽略’*‘不重复，
其次s[0..i]和p[0..j]的匹配结果也可以取决于s[0..i]和p[0..j-1]的匹配结果，意味着我们利用'*'只重复一次，
再次s[0..i]和p[0..j]的匹配结果也可以取决于s[0..i-1]和p[0..j]以及s[i]和p[j-1]的匹配结果，这个是整个递推
表达式当中最难理解的部分，其含义是
如果s[0..i-1]和p[0..j]匹配了，说明当前的’*‘在一个字符之前的原串中已经得到匹配，那么要跟当前这个
字符匹配则只需要判断当前的s[i]和p[j-1]是否匹配即可，显然j必须要大于0，这里其实暗含了’*‘重复多次
的情形，试想s[0..i-1]都和p[0..j]匹配了，那么如果当时的匹配是不重复的匹配，那好，那么这次就是重复
一次的匹配，如果当时是重复n次的匹配，那么经过这次匹配就变成了重复n+1次的匹配了，那么可能有人
要问了既然第三项包含了重复一次的匹配，为何还需要第二项s[0..i]和p[0..j-1]匹配结果，原因是第三项建立
在s[0..i-1]和p[0..j]匹配的基础之上，完全有可能s[0..i-1]和p[0..j]不匹配，然而s[0..i]和p[0..j-1]匹配，应该这么说
’*‘重复一次的匹配有两种，一种是s[0..i-1]和p[0..j-2]匹配再加上当前s[i]和p[j-1]匹配或者s[0..i]和p[0..j-1]匹配。
简而言之：
状态转移方程如下：
dp[i][j] =
c1. p[j+1] != '*'时 if s[i] == p[j] dp[i][j] = dp[i+1][j+1]
else dp[i][j] = false
c2 p[j+1] == '*'时 (这个情况下，要扩展 *, dp[i][j] 从拓展的情况下，选择一个是真的结果）
if( s[i] == p[j] || p[j] == '.' && (*s) != 0) 当s[i] 和 p[j] 一样的时候，例如 aba, a*b这个时候，i = 0, j = 0, 自然可以匹配a a
如果p[j] == . 因为他可以匹配任何字符，所以和相等关系有基本一样的方式。
并且每一步匹配都要递增 i 的值，如果有成立的，则返回true，否则到匹配终了，返回通配符匹配完成后的结果。
bool isMatch(char* s, char* p) {
int i, j;
int m = strlen(s);
int n = strlen(p);
/**
* b[i + 1][j + 1]: if s[0..i] matches p[0..j]
* if p[j] != '*'
* b[i + 1][j + 1] = b[i][j] && s[i] == p[j]
* if p[j] == '*', denote p[j - 1] with x,
* then b[i + 1][j + 1] is true if any of the following is true
* 1) "x*" repeats 0 time and matches empty: b[i + 1][j -1]
* 2) "x*" repeats 1 time and matches x: b[i + 1][j]
* 3) "x*" repeats >= 2 times and matches "x*x": s[i] == x && b[i][j + 1]
* '.' matches any single character
*/
bool b[m + 1][n + 1];
b[0][0] = true;
for (i = 0; i < m; i++) {
b[i + 1][0] = false;
}
// p[0..j - 2, j - 1, j] matches empty if p[j] is '*' and p[0..j - 2] matches empty
for (j = 0; j < n; j++) {
b[0][j + 1] = j > 0 && '*' == p[j] && b[0][j - 1];
}
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (p[j] != '*') {
b[i + 1][j + 1] = b[i][j] && ('.' == p[j] || s[i] == p[j]);
} else {
b[i + 1][j + 1] = b[i + 1][j - 1] && j > 0 || b[i + 1][j] ||
b[i][j + 1] && j > 0 && ('.' == p[j - 1] || s[i] == p[j - 1]);
}
}
}
return b[m][n];
}