#9 正则表达式

自己写的代码

思路：

1. 使用两个变量指示两个不同的string
2. 先检查元素是否相等，是否为特殊字符* 与.
3. 之后使用循环设置在碰到上述两字符之后开始循环检测
   我理解错了正则表达式中.的用法！！！是任意匹配一个字符，而不是匹配前面的一个字符！！！
   .字符匹配一个任意的字符
   *字符匹配前面0个或者多个字符（可以匹配0个一定要记好）
   但是吧，我发现我自己写的代码经常栈溢出堆溢出。。。说明对于数组下标使用不太熟练。

class Solution {
public:
 	bool isMatch(string s, string p) {
  	int slth = s.size();
  	int plth = p.size();
  	if (plth > slth) return false;
  	//i为p用，遍历使用只在最后递增
  	//j为s用，如果p碰到特殊字符就进入循环
  	int i = 0, j = i;
  	while (i < plth && j < slth)
  {
   	if (s[j] != p[i] && !(p[i] == '*' || p[i] == '.'))
    		return false;
   	else j++;
   	if (p[i] == '*')
   {
   		while (s[j] == p[i - 1])
     		j++;
   }
   	if (p[i] == '.') {
    	if (s[j] != p[i - 1]) return false;
    		j++;
   }
   	i++; j++;
  }
  	if (j == slth + 1) return true;
  	else return false;
 }};

递归解法

递归解法就是我立足于当下之后的问题都借助于已经搞好的东西解决。

class Solution {
public:
bool isMatch(string s, string p) {
  	if (p.empty()) return s.empty();
  	auto first_match = !s.empty() && (s[0] == p[0] || p[0] == '.');
  	if (p.length() >= 2 && p[1] == '*') {
   		return isMatch(s, p.substr(2)) || (first_match && isMatch(s.substr(1), p));
  }
 	 else {
  		return first_match && isMatch(s.substr(1), p.substr(1));
  }
 }
};

以s、p首部缩减的方式，递归。有以下几种情况：

1. p长度 >= 2 而且 p[1] == ‘*’

• 1.1 p[0]不等于s[0]：s不变，p截断前两位，递归。
• 1.2 p[0]等于s[0]：
  (1) * 代表0的情况：s不变，p截断前两位，递归。
  (2) * 代表1的情况：s截取首位，p不变，递归。

2. p长度 >= 2 而且 p[1] != ‘*’

• 2.1 p[0]不等于s.[0]：return false;
• 2.2 p[0]等于s.[0]: s、p各截取首位，递归。

3. p长度 = 1

• 3.1 p[0]不等于s.[0]：return false;
• 3.2 p[0]等于s.[0]: s、p各截取首位，递归。

4. p长度 = 0：
   如果s长度为0, true；如果s长度不为0, false.

动态规划解法：

vector<vector<bool>>flag(len1 + 1, vector<bool>(len2 + 1, false));
flag[0][0] = true; 边界情况
这里flag[i][j]表示pattern[0~j - 1]是否可以匹配str[0~i - 1],
(注意flag[i][j] 对于pattern[j - 1] str[i - 1])
首先列出动态转移方程
第一种情况：
pattern[j - 1] == str[i - 1] || pattern[j - 1] == '.'
有flag[i][j] = flag[i - 1][j - 1];
第二种情况：
pattern[j - 1] == '*'
第二种情况的第一个分支
str[i - 1] == pattern[j - 2] || pattern[j - 2] == '.'
有flag[i][j] = (flag[i][j - 2] || flag[i][j - 1] || flag[i - 1][j]);
(三种情况分别对应：* 号让前面字符出现0次、出现1次、出现2次及以上)
第二种情况第二个分支
flag[i][j] = flag[i][j - 2]; (*号只能让前面的字符出现0次)
第三种情况：
flag[i][j] = false;
其次在动态规划前需要考虑好初始条件
for (int i = 1; i <= len2; ++i) {
 if (pattern[i - 1] == '*')
  flag[0][i] = flag[0][i - 1] || flag[0][i - 2];
 这是为了解决类似  "" 和 ".*.*a*a*b*"这种情况 因为这种也是符合的
}

bool isMatch(string str, string pattern) {
 	int len1 = str.size();
 	int len2 = pattern.size();
 	if (len2 && pattern[0] == '*')
  	return false;
 	vector<vector<bool>>flag(len1 + 1, vector<bool>(len2 + 1, false));
 	flag[0][0] = true;
 	for (int i = 1; i <= len2; ++i) {
  		if (pattern[i - 1] == '*')
   			flag[0][i] = flag[0][i - 1] || flag[0][i - 2];
 	}
 	
 	for (int i = 1; i <= len1; ++i) {
 		 for (int j = 1; j <= len2; ++j) {
   			if ((pattern[j - 1] == str[i - 1]) || (pattern[j - 1] == '.'))
    				flag[i][j] = flag[i - 1][j - 1];
   			else if (pattern[j - 1] == '*') {
    				if ((str[i - 1] == pattern[j - 2]) || (pattern[j - 2] == '.')) {
     					flag[i][j] = (flag[i][j - 2] || flag[i][j - 1] || flag[i - 1][j]);
   				 }
   				else {
     					flag[i][j] = flag[i][j - 2];
   				 }   				  
 }
   			else {
   				flag[i][j] = false;
   } }}
 	return flag[len1][len2];
}