https://leetcode-cn.com/problems/regular-expression-matching/
分析
这道题的难点在于存在a*
这样的组合,如何处理与这种组合匹配的字符数是很棘手的问题,例如:
s = "aaa", p = "aa*"
s = "baaa", p = "ba*"
第一个例子中a*
匹配2个字符,第二个例子中a*
匹配3个字符。可以看出,匹配的字符数不仅与s有关,还与p中组合前面的字符有关(后面也有可能)。如果是.*
这样的组合,会更加麻烦。
我一开始的想法是用双指针分别遍历s和p,在遇到a*
这样的组合时通过组合后面的字符与s的匹配程度来判断a*
应该匹配的字符数。这个思路实现起来很麻烦,而且由于.*
的存在,太容易出错了。
解法
这是一道动态规划算法题,用dp[i][j]
来表示s中的前i
个字符与p中的前j
个字符是否匹配。
- 易知,当
p[j] == '.' || s[i] == p[j]
时,代表s的第i
个字符与p的第j
个字符匹配,那么dp[i][j] = dp[i-1][j-1]
- 当
p[j] == '*'
时,判断起来会比较麻烦。我的想法是,找到s中的第k
个字符,满足dp[k][j-2] == true
,即s的前k
个字符与p的前j-2
个字符(去掉组合的前面那一串)匹配。再判断s中第k+1
到第i
个字符,是否与p中第j-1
个字符匹配(要么相等,要么p[j-1] == '.'
)。
需要注意,找第k
个字符要从后往前找, 否则对于下面这种情况会出错:s = "a", p = "b*a*c*"
,dp[1][6]
应该为true
,但由于dp[0][4] == true
会导致k = 0
,从而把dp[1][6]
判断成false
。
这样做的目的也是为了让更少的s[k+1:i]
去与p[j-1]
进行比较。
这种方法挺麻烦,而且时间复杂度也会高一些,但比较容易想到。 - 若上述两种情况都不满足,那么
dp[i][j] = false
class Solution {
public:
bool isMatch(string s, string p) {
bool dp[s.length() + 1][p.length() + 1]; // dp[i][j]:s前i个字符与p前j个字符是否匹配
for (int i = 0; i < s.length() + 1; ++i) dp[i][0] = false;
for (int j = 0; j < p.length() + 1; ++j) dp[0][j] = false;
dp[0][0] = true;
for (int i = 0; i <= s.length(); ++i) {
for (int j = 1; j <= p.length(); ++j) {
if (p[j - 1] == '*') {
bool flag = false;
int k;
for (k = i; k >= 0; --k) {
if (dp[k][j - 2]) {
flag = true;
break;
}
}
if (!flag) {
dp[i][j] = false;
continue;
}
if (p[j - 2] == '.') dp[i][j] = true;
else {
k++;
flag = true;
while (k <= i) {
if (s[k - 1] != p[j - 2]) {
flag = false;
break;
}
k++;
}
dp[i][j] = flag;
}
}
else if (i == 0) dp[i][j] = false;
else {
dp[i][j] = dp[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '.');
}
}
}
return dp[s.length()][p.length()];
}
};
代码如上,处理*
的那里编码很繁琐,但算法运行时间倒挺快的,leetcode上只有4ms,超过了96.88%的解答,这挺奇怪,我找k
和判断k+1~i
应该都花了额外时间,这个算法的时间复杂度肯定不是最优的。
官方题解给出了对于第2种情况更好的处理办法,其主要思想是,要匹配a*
这样的组合,不论用多少个字符去匹配,其本质都是两种选择:
- 匹配第
i
个字符,将其扔掉,再继续判断是否匹配第i-1
个字符 - 不匹配第
i
个字符,直接将这个组合扔掉
这样的话,对于第二种情况,状态转移方程就是
dp[i][j] = dp[i][j-2] || dp[i-1][j]
,当s[i]
与p[j-1]
匹配dp[i][j] = dp[i][j-2]
,当s[i]
不与p[j-1]
匹配
代码
class Solution {
public:
bool isMatch(string s, string p) {
bool dp[s.length() + 1][p.length() + 1]; // dp[i][j]:s前i个字符与p前j个字符是否匹配
for (int i = 0; i < s.length() + 1; ++i) dp[i][0] = false;
for (int j = 0; j < p.length() + 1; ++j) dp[0][j] = false;
dp[0][0] = true;
for (int i = 0; i <= s.length(); ++i) {
for (int j = 1; j <= p.length(); ++j) {
if (p[j - 1] == '*') {
if (i == 0 || s[i - 1] != p[j - 2] && p[j - 2] != '.') {
dp[i][j] = dp[i][j - 2];
}
else {
dp[i][j] = dp[i][j - 2] || dp[i - 1][j];
}
}
else if (i == 0) dp[i][j] = false;
else {
dp[i][j] = dp[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '.');
}
}
}
return dp[s.length()][p.length()];
}
};
这个代码更加简洁明了,而且时间复杂度也减小了。
细节
首先,采用bool
数组来存储状态,一定要注意初始化,因为bool
的初始值并不一定是true
或者false
,而是随机的一个值,直接用的话容易出错。
其次,dp[0][j]
并不一定全是false
的,即空串也是能够满足正则表达式匹配的,例如a*
就能匹配一个空串。
数组下标索引是从0
开始的,所以在前面思路中的s[i]
和p[j]
,在代码里都要替换成s[i-1]
和p[j-1]
,dp
相关的则不用。
复杂度分析
时间复杂度为
O
(
m
n
)
O(mn)
O(mn),空间复杂度为
O
(
m
n
)
O(mn)
O(mn)。空间应该优化到
O
(
n
)
O(n)
O(n),之后再做吧。
优化空间复杂度后的代码:
class Solution {
public:
bool isMatch(string s, string p) {
bool dp[p.length() + 1]; // dp[j]:s前i个字符与p前j个字符是否匹配
for (int j = 1; j <= p.length(); ++j) dp[j] = false;
dp[0] = true;
for (int i = 0; i <= s.length(); ++i) {
bool leftNor = dp[0];
dp[0] = i == 0 ? true : false;
for (int j = 1; j <= p.length(); ++j) {
bool tmp = dp[j];
if (p[j - 1] == '*') {
if (i == 0 || s[i - 1] != p[j - 2] && p[j - 2] != '.') {
dp[j] = dp[j - 2];
}
else {
dp[j] = dp[j - 2] || dp[j];
}
}
else if (i == 0) dp[j] = false;
else {
dp[j] = leftNor && (s[i - 1] == p[j - 1] || p[j - 1] == '.');
}
leftNor = tmp;
}
}
return dp[p.length()];
}
};
需要特别注意的就是leftNor
变量的初始化。