Leetcode困难笔记 10.正则表达式匹配

记录一次leetcode困难题的解题过程。

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素

所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

说明:

• s 可能为空，且只包含从 a-z 的小写字母。
• p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

解题开始

看到题目，开始思考，逐渐挣扎，尝试硬解(解题错误示范)。

硬解过程就是模拟匹配过程，开始逐个字符匹配。

遇到 ‘*’ 时取得前一个字符，然后经过’简单’的逻辑判断后递归。

遇到 ‘.’ 或者字符相等时，继续下一个字符的匹配。

否则去看下一个字符是不是 ‘*’ 字符。
…
经过一番折腾，完成了一段充满补丁的代码。

class Solution {
public:
	bool isMatch(string s, string p, int i = 0, int j = 0) {
		while( j < p.size() )
		{
			if( p[j] == '*' )
			{
				if( j < 1 ) return false; 
				char pre = p[j-1];
				i--, j++;
				if( pre == '.' )
				{
					if( i > s.size() )	return false;
					if( j == p.size() )	return true;
					while(1)
					{
						if( i > s.size() )	return false;
						if( isMatch(s, p, i, j) )	return true;
						i++;
					}
				}
				else if( pre == '*' )
					return false;
				else
				{
					for( ; i < s.size() && s[i] == pre; i++)
					{
						if( isMatch(s, p, i, j) )	return true;
					}
				}
				continue;
			}
			else if( p[j] == '.' || (i < s.size() && s[i] == p[j]) )
				i++, j++;
			else
			{
				if( j+1 < p.size() && p[j+1] == '*' )
				{
					j += 2;
					continue;
				}
				return false;
			}
		}
		return i == s.size() && j == p.size();
	}
};

嗯，勉勉强强通过，这种强硬的写法没什么技巧性，新手还是乖乖看答案吧，于是低头跑去看题解。

题解 https://leetcode-cn.com/problems/regular-expression-matching/solution/zheng-ze-biao-da-shi-pi-pei-by-leetcode/

动手改成了C++的格式。

解题方法1 : 回溯法

class Solution {
public:
	bool isMatch(string s, string p)
	{
		if(p.empty()) return s.empty();
		bool first_match = (!s.empty() && (p[0] == s[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));
		}
	}
};

陷入沉思，怎么这么短，我写了啥来着，又一条咸鱼失去了梦想，开始代码分析。

• first_match 表示两个字符串首字符是否匹配
• p.substr(2)返回从p[2]到结尾的子串

条件判断 : 当匹配字符串长度大于等于2并且第二个字符为 ‘*’

• 递归调用 isMatch(s, p.substr(2))，即 ‘*’ 匹配零个元素的情况

• 首字符相等并递归调用 isMatch(s.substr(1), p)，即 ‘*’ 匹配了一个首元素，然后去匹配下一个元素的情况。这个过程中匹配字符串是没有变化的，例如，s为 “aaX”，匹配字符串为 “a*X” 时（其中X表示各自剩余的字符串），递归调用为 isMatch(“aX”, “a*X”)，首字符 ‘a’ 成功匹配

不成立的情况 ：

• 如果首字符不匹配的话，由于逻辑符短路，直接返回 false
• 调用 isMatch(s.substr(1), p.substr(1)) 来进行下一个字符的匹配

嗯?匹配完成了?好像是完成了，我想删代码了，算了，改改还能用。

解题方法2 : 动态规划

class Solution {
public:
	bool isMatch(string s,string p)
	{
		vector<vector<int> > dp(s.length()+1,vector<int>(p.length()+1,1));
		for(int i = s.length(); i >= 0; i--) {
			for(int j = p.length()-1; j >= 0; j--) {
				bool first_match = (i < s.length() && (p[j] == s[i] || p[j] == '.'));
				if(j+1 < p.length() && p[j+1] == '*') {
					dp[i][j] = dp[i][j+2] || first_match && dp[i+1][j];
				} else {
					dp[i][j] = first_match && dp[i+1][j+1];
				}
			}
		}
		return dp[0][0];
	}
};

动态规划的过程与回溯的过程相似，不过是增加了dp数组来保存递归的结果。

其中 dp[i][j] 表示s从i到结尾的字符串和p从j到结尾的字符串是否匹配。