剑指 Offer 19. 正则表达式匹配

 这道题就是有大量的情况需要考虑

1关于'.'怎么匹配（不考虑*的情况）

bool isMatch(string s, string p) {
    int i = 0, j = 0;
    while (i < s.size() && j < p.size()) {
        // 「.」通配符就是万金油
        if (s[i] == p[j] || p[j] == '.') {
            // 匹配，接着匹配 s[i+1..] 和 p[j+1..]
            i++; j++;
        } else {
            // 不匹配
            return false;
        }
    }
    return i == j;
}

2考虑带'*'怎么匹配

if (s[i] == p[j] || p[j] == '.') {
    // 匹配
    if (j < p.size() - 1 && p[j + 1] == '*') {
        // 有 * 通配符，可以匹配 0 次或多次
    } else {
        // 无 * 通配符，老老实实匹配 1 次
        i++; j++;
    }
} else {
    // 不匹配
    if (j < p.size() - 1 && p[j + 1] == '*') {
        // 有 * 通配符，只能匹配 0 次
    } else {
        // 无 * 通配符，匹配无法进行下去了
        return false;
    }
}

如果匹配，即s[i] == p[j]

• 1.1p[j]有可能会匹配多个字符，比如s = "aaa", p = "a*"，那么p[0]会通过*匹配 3 个字符"a"。
• 1.2p[i]也有可能匹配 0 个字符，比如s = "aa", p = "a*aa"，由于后面的字符可以匹配s，所以p[0]只能匹配 0 次。

如果不匹配，即s[i] != p[j]，只有一种情况：

• p[j]只能匹配 0 次，然后看下一个字符是否能和s[i]匹配。比如说s = "aa", p = "b*aa"，此时p[0]只能匹配 0 次
• 其他情况就是直接返回false，匹配不上

3 定义dp函数

 boolean helper (String s,int i,String p,int j)

• 表示s被匹配串从i开始，p匹配串从j开始匹配，如何能够匹配上就返回ture,匹配不上就返回false

bool dp(string& s, int i, string& p, int j) {
    if (s[i] == p[j] || p[j] == '.') {
        // 匹配
        if (j < p.size() - 1 && p[j + 1] == '*') {
            // 1.1 通配符匹配 0 次或多次
            return dp(s, i, p, j + 2)
                || dp(s, i + 1, p, j);
        } else {
            // 1.2 常规匹配 1 次
            return dp(s, i + 1, p, j + 1);
        }
    } else {
        // 不匹配
        if (j < p.size() - 1 && p[j + 1] == '*') {
            // 2.1 通配符匹配 0 次
            return dp(s, i, p, j + 2);
        } else {
            // 2.2 无法继续匹配
            return false;
        }
    }
}

1.1通配符匹配0次

 1.1通配符匹配多次

1.2正常匹配一次 

2.1这种情况只有*匹配0次可能会匹配成功，跟1.1的匹配0次的情况一样

 2.2如果没有*,直接表示匹配失败

关于base case的定义

• 一个 base case 是j == p.size()时，按照dp函数的定义，这意味着模式串p已经被匹配完了，那么应该看看文本串s匹配到哪里了，如果s也恰好被匹配完，则说明匹配成功：

  if(j==n){
            return i==m;
            //说明我们的匹配串已经到头了，只有被匹配串也匹配完，才说明匹配上了
        }

• 另一个 base case 是i == s.size()时，按照dp函数的定义，这种情况意味着文本串s已经全部被匹配了，那么是不是只要简单地检查一下p是否也匹配完就行了呢？

 if(i==m){
            //被匹配串走到了尽头，如果我们的匹配串还没有走到尽头，也不一定说匹配不上
            //因为还存在一种可以匹配空字符串的可能
            if((n-j)%2==1){
                return false;
                //因为匹配空字符串只有一种可能就是 a* b* c*
                //所以能匹配空串的匹配串肯定是偶数的
            }
            for(;j+1<n;j+=2){
                if(p.charAt(j+1)!='*'){
                    return false;
                }
            }
            return true;
        }

最后就是加上一个备忘录，进行记忆化搜索

class Solution {
    int  dp[][];//1 表示匹配上了 2表示没有匹配上
    public boolean isMatch(String s, String p) {
        int m=s.length();
        int n=p.length();
        dp=new int[m+1][n+1];
        for(int []arr:dp){
            Arrays.fill(arr,-1);
        }
        return helper(s,0,p,0);
    }
    public boolean helper (String s,int i,String p,int j){
        int m=s.length();
        int n=p.length();
        if(j==n){
            return i==m;
            //说明我们的匹配串已经到头了，只有被匹配串也匹配完，才说明匹配上了
        }
        if(i==m){
            //被匹配串走到了尽头，如果我们的匹配串还没有走到尽头，也不一定说匹配不上
            //因为还存在一种可以匹配空字符串的可能
            if((n-j)%2==1){
                return false;
                //因为匹配空字符串只有一种可能就是 a* b* c*
                //所以能匹配空串的匹配串肯定是偶数的
            }
            for(;j+1<n;j+=2){
                if(p.charAt(j+1)!='*'){
                    return false;
                }
            }
            return true;
        }
        if(dp[i][j]!=-1){
            if(dp[i][j]==1){
                return true;
            }else{
                return false;
            }
        }
        boolean res=false;
        if(s.charAt(i)==p.charAt(j)||p.charAt(j)=='.'){
            //说明当前字符是匹配上了 

            if(j<n-1 && p.charAt(j+1)=='*'){
                //说明是*匹配,这种匹配上了 可以匹配0次或者多次
                res=helper(s,i,p,j+2)||helper(s,i+1,p,j);
            }else{
                //说明不是*匹配 那么就正常的匹配一次
                res=helper(s,i+1,p,j+1);
            }
        }else{
            //说明当前匹配的字符是不匹配的
            if(j<n-1&&p.charAt(j+1)=='*'){
                //这种情况，只能是匹配0次这种情况
                res=helper(s,i,p,j+2);
            }else{
                res=false;
                //这种就直接说明匹配不上
            }
        }
        if(res){
            dp[i][j]=1;
        }else{
            dp[i][j]=2;
        }
        return res;
    }
}