动态规划求解正则表达式：给定一个字符串 (s) 和一个字符模式 (p)

给定一个字符串 s 和一个字符模式 p。实现支持 ‘.’ 和 ‘*’ 的正则表达式匹配。
‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素

说明: 匹配应该覆盖整个字符串 (s) ，而不是部分字符串。
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

暴力递归

bool isMatch(string text, string pattern) {
	if (pattern.empty())return text.empty();
	bool first = false;
	if (!text.empty() && (pattern[0] == text[0] || pattern[0] == '.')) {
		first = true;
	}
	if (pattern.size() >= 2 && pattern[1] == '*') {
		return isMatch(text, pattern.substr(2))
				|| (first && isMatch(text.substr(1), pattern));
	} else {
		return first && isMatch(text.substr(1), pattern.substr(1));
	}
	
}

带备忘录的递归

思路：f[i][j]表示s的前i个字符和p的前j个字符是否能够匹配

	bool isMatch(string s, string p) {
		int m = s.size();
		int n = p.size();
		//判断s的第i个字符和p的第j个字符是否匹配
		auto matches = [&](int i, int j) {
			if (i == 0)  return false;
			if (p[j - 1] == '.')  return true;
			return s[i - 1] == p[j - 1];
		};
		
		vector<vector<int>> f(m + 1, vector<int>(n + 1));
		f[0][0] = true;
		for (int i = 0; i <= m; ++i) {
			for (int j = 1; j <= n; ++j) {
				if (p[j - 1] == '*') {
				//两个if覆盖了*号和*号前面一个字符的两种情况：一种是不匹配，一种是匹配
					if (j >= 2)
						f[i][j] |= f[i][j - 2]; //*号和*号前面一个字符不匹配字符串，则f[i][j]是否为真根据f[i][j-2]的值判断
					if (matches(i, j - 1)) //*号前面的字符可以匹配，则看f[i - 1][j]是否为真
						f[i][j] |= f[i - 1][j];
				} else {
					if (matches(i, j)) //如果不能匹配上：f[i][j]不作操作，还是0
						f[i][j] |= f[i - 1][j - 1]; //匹配上：则看f[i-1][j-1]的值
				}
			}
		}
		return f[m][n];
	}