【LeetCode.10 正则表达式匹配】

【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%。。