1、题目描述
给你一个字符串 s 和一个字符规律 p,请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素
所谓匹配,是要涵盖 整个 字符串 s的,而不是部分字符串。
说明:
s 可能为空,且只包含从 a-z 的小写字母。
p 可能为空,且只包含从 a-z 的小写字母,以及字符 . 和 *。
2、示例
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此,字符串 "aa" 可被视为 'a' 重复了一次。
输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个('*')任意字符('.')。
输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个,这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
3、题解
解法一:简化版
- 动态规划,初始化dp[i][j]=false
- 如果s[i-1]==p[j-1]||p[j-1]=='.',则dp[i][j]=dp[i-1][j-1]
- 如果p[j-1]=='*',可以选择匹配0次则dp[i][j]=dp[i][j-2],可以选择匹配一次这时候必须s当前字符和p前一个字符匹配,匹配完因为*可以继续匹配字符,所以相当于忽略了s中的当前字符(也可以想成是s中增长了一个字符,此时p中*匹配了这个字符所以要看dp[i-1][j]增长这个字符之前是否匹配),所以还必须满足dp[i-1][j]
解法二:递归回溯法
采用递归回溯法就是因为当s="aaaa" p="aaa*aa"时p下标j指向*时不知道是匹配还是不匹配,所以如果匹配错了可以通过递归回溯找到所有匹配可能情况。容易理解,空间时间复杂度高。
- 采用从后往前匹配,因为如果我们从前往后匹配,每个字符我们都得判断是否后面跟着'*'还是字母,但是从后往前没这个问题,一旦j遇到'*',j-1必然有个字符
- 如果j已经<0了说明p已经匹配完了,这时候,如果s也匹配完了说明正确,如果s没匹配完说明错误;如果i已经<0了说明s已经匹配完,这时候,p可以没匹配完,只要它还有'*'存在,继续执行代码,所以这种情况不用单独拿出来考虑
- 总共两种匹配方式p[j]=='.'||s[i]==p[j]或者p[j]=='*'时可以匹配,所以有两个if单独处理
- ①当p[j]='*'时有三种处理情况,第一种是p[j-1]=='.'||s[i]==p[j-1]情况匹配1个元素i-1,第二种是p[j-1]=='.'||s[i]==p[j-1]情况但是不匹配直接跳过j-2,第三种情况是p[j-1]!='.'&&s[i]!=p[j-1]不匹配跳过j-2
- 对于一情况可以匹配直接匹配字符串s中的一个元素i-1,j不变'*'可以继续匹配使用
- 对于二、三情况都是跳过j-2无论是可以匹配主动跳过还是不可以匹配被动跳过,都是j-2一起考虑
- ②当p[j]!='*' 即p[j]=='.'||s[i]==p[j]情况时,直接匹配,i-1,j-1
解法三:动态规划法
所有字符串匹配问题都可以用动态规划法,利用已匹配的信息计算未匹配的信息。
- dp[i][j]表示s[0,i-1]前i个字符与p[0,j-1]前j个字符是否匹配,true匹配,false不匹配
- 初始化dp,dp[0][0]=true,dp[i][0]=false,当j=0即p为空时,s只有i=0为空时才匹配,其他情况都无法匹配;只有a*能匹配空串,如果p有*(p[j-1]='*'),那么dp[0][j]一定和dp[0][j-2]的相同
- 总共两种匹配方式p[j]=='.'||s[i]==p[j]或者p[j]=='*'时可以匹配
- ①当p[j]='*'时有三种处理情况,第一种是p[j-1]=='.'||s[i]==p[j-1]情况匹配1个元素i-1,第二种是p[j-1]=='.'||s[i]==p[j-1]情况但是不匹配直接跳过j-2,第三种情况是p[j-1]!='.'&&s[i]!=p[j-1]不匹配跳过j-2
- 对于二、三情况都是跳过*符号匹配0次,或者对于一情况j不动可以多次用*符号,dp[i]不断等于dp[i-1]相当于多次利用*匹配
- ②dp[i][j]表示s[0,i-1]与p[0,j-1]是否匹配取决于p[j-1]=='.'||s[i-1]==p[j-1]字符匹配且dp[i-1][j-1]=true
- 返回dp[s_len][p_len],s[0,s_len-1]前s_len个字符与p[0,p_len-1]前p_len个字符是否匹配
#include<iostream>
#include<string>
#include<vector>
using namespace std;
class Solution {
public:
bool isMatch(string s, string p) {
//简化版:动态规划,初始化dp[i][j]=false,
//如果s[i-1]==p[j-1]||p[j-1]=='.',则dp[i][j]=dp[i-1][j-1]
//如果p[j-1]=='*',可以选择匹配0次则dp[i][j]=dp[i][j-2],可以选择匹配一次这时候必须s当前字符和p前一个字符匹配,匹配完因为*可以继续匹配字符,所以相当于忽略了s中的当前字符(也可以想成是s中增长了一个字符,此时p中*匹配了这个字符所以要看dp[i-1][j]增长这个字符之前是否匹配),所以还必须满足dp[i-1][j]
vector<vector<bool>> dp(s.size()+1,vector<bool>(p.size()+1,false));
dp[0][0]=true;
for(int i=2;i<=p.size();i++)
{
if(p[i-1]=='*')
dp[0][i]=dp[0][i-2];
}
for(int i=1;i<=s.size();i++)
{
for(int j=1;j<=p.size();j++)
{
if(s[i-1]==p[j-1]||p[j-1]=='.')
dp[i][j]=dp[i-1][j-1];
else if(p[j-1]=='*')
dp[i][j]=dp[i][j-2]||(s[i-1]==p[j-2]||p[j-2]=='.')&&dp[i-1][j];
}
}
return dp[s.size()][p.size()];
}
};
//递归回溯法:容易理解,空间时间复杂度高
class Solution1 {
public:
bool isMatch(string s, string p) {
//采用从后往前匹配,因为如果我们从前往后匹配,每个字符我们都得判断是否后面跟着'*'还是字母,但是从后往前没这个问题,一旦j遇到'*',j-1必然有个字符
return recursionMatch(s, s.size() - 1, p, p.size() - 1);
}
bool recursionMatch(string s, int i, string p, int j)
{
//如果j已经<0了说明p已经匹配完了,这时候,如果s也匹配完了说明正确,如果s没匹配完说明错误
//如果i已经<0了说明s已经匹配完,这时候,p可以没匹配完,只要它还有'*'存在,继续执行代码,所以这种情况不用单独拿出来考虑
if (j == -1)
if (i == -1)
return true;
else
return false;
//总共两种匹配方式p[j]=='.'||s[i]==p[j]或者p[j]=='*'时可以匹配,所以有两个if单独处理
if (p[j] == '*') //当p[j]='*'时有三种处理情况,第一种是p[j-1]=='.'||s[i]==p[j-1]情况匹配1个元素i-1,第二种是p[j-1]=='.'||s[i]==p[j-1]情况但是不匹配直接跳过j-2,第三种情况是p[j-1]!='.'&&s[i]!=p[j-1]不匹配跳过j-2
{
if (i >= 0 && (p[j - 1] == '.' || s[i] == p[j - 1])) //对于一情况可以匹配直接匹配字符串s中的一个元素i-1,j不变'*'可以继续匹配使用
if(recursionMatch(s, i - 1, p, j)) //用if而不是直接return是因为尝试这种情况能不能完全匹配,如果这种情况不行并不代表其他情况也不行
return true;
return recursionMatch(s, i, p, j - 2); //对于二、三情况都是跳过j-2无论是可以匹配主动跳过还是不可以匹配被动跳过,都是j-2一起考虑
}
if (i >= 0 && (p[j] == '.' || s[i] == p[j])) //当p[j]!='*' 即p[j]=='.'||s[i]==p[j]情况时,直接匹配,i-1,j-1
{
return recursionMatch(s, i - 1, p, j - 1);
}
//以上两种情况都不匹配,返回false
return false;
}
};
//动态规划法:难理解,时间空间复杂度低
class Solution2 {
public:
bool isMatch(string s, string p) {
int s_len = s.size(), p_len = p.size();
bool dp[100][100]; //dp[i][j]表示s[0,i-1]前i个字符与p[0,j-1]前j个字符是否匹配,true匹配,false不匹配
int i, j; //i表示字符串s的下标,j表示字符串p的下标
bool temp = false;
dp[0][0] = true; //当s和p同时为空时,匹配成功
//初始化dp,dp[i][0]=false,当j=0即p为空时,s只有i=0为空时才匹配,其他情况都无法匹配
for (i = 1; i <= s_len; i++)
dp[i][0] = false;
//初始化dp,只有a*能匹配空串,如果p有*(p[j-1]='*'),那么dp[0][j]一定和dp[0][j-2]的相同
for (j = 2; j <= p_len; j++) //因为'*'在字符串p中出现的位置最前是下标1所以j-1>=1并且dp中j-2>=0,所以j从2开始
{
if (p[j - 1] == '*') //dp的j下标在字符串p中下标是j-1
dp[0][j] = dp[0][j - 2];
else
dp[0][j] = false;
}
for (i = 1; i <= s_len; i++)
{
for (j = 1; j <= p_len; j++)
{
//总共两种匹配方式p[j]=='.'||s[i]==p[j]或者p[j]=='*'时可以匹配
//当p[j]='*'时有三种处理情况,第一种是p[j-1]=='.'||s[i]==p[j-1]情况匹配1个元素i-1,第二种是p[j-1]=='.'||s[i]==p[j-1]情况但是不匹配直接跳过j-2,第三种情况是p[j-1]!='.'&&s[i]!=p[j-1]不匹配跳过j-2
if (p[j - 1] == '*')
{
//对于二、三情况都是跳过*符号匹配0次,或者对于一情况j不动可以多次用*符号,dp[i]不断等于dp[i-1]相当于多次利用*匹配
dp[i][j] = dp[i][j - 2] || ((s[i - 1] == p[j - 2] || p[j - 2] == '.') && dp[i - 1][j]);
}
else
{ //dp[i][j]表示s[0,i-1]与p[0,j-1]是否匹配取决于p[j-1]=='.'||s[i-1]==p[j-1]字符匹配且dp[i-1][j-1]=true
dp[i][j] = (s[i - 1] == p[j - 1] || p[j - 1] == '.') && dp[i - 1][j - 1];
}
}
}
//返回dp[s_len][p_len],s[0,s_len-1]前s_len个字符与p[0,p_len-1]前p_len个字符是否匹配
return dp[s_len][p_len];
}
};
int main()
{
Solution1 solute1;
Solution2 solute2;
//考虑最特殊的一个样例,a*可能直接跳过,也可能用于匹配s[1]=a,所以采用递归回溯的方法,如果匹配不成功回溯
string s = "aaaa";
string p = "aa*aa";
cout << solute1.isMatch(s, p) << endl;
cout << solute2.isMatch(s, p) << endl;
return 0;
}