【LeetCode.10 正则表达式匹配】
10. 正则表达式匹配
给你一个字符串 s
和一个字符规律 p
,请你来实现一个支持 '.'
和 '*'
的正则表达式匹配。
'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素
所谓匹配,是要涵盖 整个 字符串 s
的,而不是部分字符串。
说明:
s
可能为空,且只包含从a-z
的小写字母。p
可能为空,且只包含从a-z
的小写字母,以及字符.
和*
。
【分析】这道题曾经困扰了我好久……直到今天看到力扣官方题解有点思路,记录一下。这道题可以用动态规划来解,设函数f(i,j)
表示字符串s前i个字符和模式p的前j个字符是否匹配。那么对于一般的i,j 有如下关系:
f(i,j)=s[i]==p[j]&f(i-1,j-1) --------------------------如果p[j]为普通字符
f(i,j)=f(i-1,j-1)--------------------------------------如果p[j]为.
f(i,j)=f(i,j-2)|(f(i-1,j)&(p[j-1]=='.'|p[j-1]=s[i]))---如果p[j]为*
base case是:空串和空模式匹配;空模式和任意字符串不匹配;空字符串只能和全通配模式匹配(即全都是类似a*或者.*)。
f(i,j)=true-------------------i=0,j=0
f(i,j)=false------------------i!=0,j=0
f(i,j)=allStar(p,j)-----------i=0,j!=0
因此可以写出动态规划算法。注意,公式里的i,j在实际数组里应该转换成i-1,j-1,因为f(0,0)是空串和空模式匹配。
【解法一】
class Solution {
public boolean isMatch(String s, String p) {
return solve(s.toCharArray(),p.toCharArray());
}
boolean solve(char[] s,char[] p) {
int I=s.length+1,J=p.length+1;
boolean[][] dp=new boolean[I][J];
//00表示空位置,实际从1开始取
dp[0][0]=true;
for(int j=1;j<J;j++) {
dp[0][j]=allStar(p,j-1);
}
for(int i=1;i<I;i++) {
dp[i][0]=false;
}
for(int i=1;i<I;i++) {
for(int j=1;j<J;j++) {
if(p[j-1]!='*'&&p[j-1]!='.') {
dp[i][j]=s[i-1]==p[j-1]&&dp[i-1][j-1];
}
else if(p[j-1]=='.') {
dp[i][j]=dp[i-1][j-1];
}
else {
dp[i][j]=dp[i][j-2]||(dp[i-1][j]&&(p[j-2]=='.'||s[i-1]==p[j-2]));
}
}
}
return dp[I-1][J-1];
}
//0~end位置是否全为a*, end一定是奇数(索引从0开始)
boolean allStar(char[] p,int end) {
if(end %2 ==0) return false;
for(int a=0;a<=end;a++) {
if(a%2==0 && p[a]=='*') return false;
else if(a%2==1 && p[a]!='*') return false;
}
return true;
}
}
时间2ms打败99%,但是占用的空间才打败了20%。。。显然有优化空间
再看看递推公式,因为每个元素都依赖左边第二个或者左上角或者上边那个,因此可以优化一位数组。
【解法二】
class Solution {
public boolean isMatch(String s, String p) {
return solveOp(s.toCharArray(),p.toCharArray());
}
boolean solveOp(char[] s,char[] p) {
int I=s.length+1,J=p.length+1;
boolean[] dp=new boolean[J];
dp[0]=true;
for(int j=1;j<J;j++) {
dp[j]=allStar(p,j-1);
}
for(int i=1;i<I;i++) {
boolean tl=dp[0];
dp[0]=false;
for(int j=1;j<J;j++) {
boolean tmp=dp[j];
if(p[j-1]!='*'&&p[j-1]!='.') {
dp[j]=s[i-1]==p[j-1]&&tl;
}
else if(p[j-1]=='.') {
dp[j]=tl;
}
else {
dp[j]=dp[j-2]||(dp[j]&&(p[j-2]=='.'||s[i-1]==p[j-2]));
}
tl=tmp;
}
}
return dp[J-1];
}
}
时间打败99%,空间打败79%。。