Leetcode -- Regular Expression Matching

问题链接：https://oj.leetcode.com/problems/regular-expression-matching/

问题描述：Implement regular expression matching with support for '.' and '*'.

'.' Matches any single character.
'*' Matches zero or more of the preceding element.

The matching should cover the entire input string (not partial).

The function prototype should be:
bool isMatch(const char *s, const char *p)

Some examples:
isMatch("aa","a") → false
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "a*") → true
isMatch("aa", ".*") → true
isMatch("ab", ".*") → true
isMatch("aab", "c*a*b") → true

API ： public boolean isMatch(String s, String p)

这题其实有点绕和难。leetcode归类为hard应该是没有错的，除非我太水了。。。

先介绍第一种做法：Brute Force.

毕竟怎么看都是要记录当前扫的s和p的位置的，那么helper函数的长相应该是这样的：public boolean helper(String s, String p, int i, int j)

i表示扫到s哪个位置，j表示扫到了p哪个位置。

而根据题意，根据条件case有很多，譬如s[i] == p[j], p[j] == '.', p[j] == '*' 等等

但大致上可以基本上可以分类为两个case：

1. s[i] == p[j] 或者p[j] == ','。 在这种情况下，以i + 1和j + 1的前提往下递归一层即可。

2. p[j + 1] == '*'，之所以这里用j + 1做判断是因为'*'的内容是根据p[j]来的。这个时候'*'表示的是0~无限多个p[j]。所以s[i], s[i + 1]....s[s.length() - 1]都有可以和p[j + 1]匹配的可能。只要满足以下两个条件的其中之一即可p[j] == '.' 或者 p[j] ==s[i + k] (0 <= k <= s.length() - 1 - i)。 所以这个时候需要不停循环并递归s[i + 1]下一层直到不满足上述两个条件之一。

3. 上述两个case都不满足的就很简单了， return false即可。

4. 这个递归的终结点base case是if(j == p.length()) return i == s.length()。 之所以用p作为先决条件很大程度上是因为'*'的存在可以表示任意个字符（包括0个），随意性很强。这样比较容易判断。所以用if(j == p.length() && i == s.length()) 或者if(i == s.length) return j == p.length()都是不恰当的。

下面是代码：

    public boolean isMatch(String s, String p) {
        return helper(s, p, 0, 0);
    }
    
    public boolean helper(String s, String p, int l, int r) {
    //2017-10-17
    //还是补充一下这里，重新回顾的时候发现先判断r == p.length()还是有意义的
    //我想了一会儿为什么当年写的时候不用 if(l == s.length() && r == p.length()) return true 去判断
    //后来发现这个条件是必要不充分的，也就是即使l == s.length() && r != p.length()的时候，也是可以返回true的
    //就是在l == s.length()的时候，如果r在p的位置的后方全是带有*的组合。
    // ex. s = "abcd", p = "abcc*d*d*"之类的，helper(s, p, 4, 4)也是会返回true的
    // 所以用上面的if去判断，会错误的返回false。
        if (r == p.length()) return l == s.length();
        if (r + 1 < p.length() && p.charAt(r + 1) == '*') {
            while(l < s.length() && (p.charAt(r) == '.' || p.charAt(r) == s.charAt(l))) { 
                // 2023-03-21
                // 每次回看都觉得l这里应该需要加1。今天仔细想了一下，发现其实这里的递归不加才是对的
                // 理由是因为这里其实往下递归的是我们这里在s这里选择不取Match，也就是不消耗
                // s.charAt(l)去和p.charAt(r)进行配对
                // 这是因为在while loop之后的那个return helper(s, p, l, r + 2)
                // 会把s.charAt(l)和p.charAt(r)匹对的情况涵括进去。
                if(helper(s, p, l, r + 2)) return true;
                l++;
            }
            
            return helper(s, p, l, r + 2);
        } else if (l < s.length() && (p.charAt(r) == '.' || p.charAt(r) == s.charAt(l))) {
            return helper(s, p, l + 1, r + 1);
        } else return false;
    }

上述算法的复杂度是指数级别的，但是也能过leetcode测试，说明本题leetcode的检测并没有很严格。

接下来将要介绍dp的算法，其实所有的dp算法大都可以从brute force算法中看出端倪所在。dp推导式的条件随后放送。

来撸dp推导式了，dp最重要的就是推导式，有了推导式代码其实也就成型了。

然而dp的推导式基本都是可以从brute force得到的。

首先定义dp函数f(i,j)的定义，f(i,j)在这里表示的就是s[1...i]到p[1...j]是否一个可行的regular expression match

那么根据之前在brute force那样，我们可以继续分出类似的case来得到推导式：

Case 1 : 就是当p[j + 1] != '*'的情况，

这个情况比较简单，推导式就是：f(i + 1, j + 1) = f(i, j) && (s[i] == s[j] || p[j] == ".")

Case 2 : 当p[j + 1] == "*"的情况

这个情况就和之前brute force有点不一样了，还需要分两个sub case来分析。

Case 2.a : p[i] == '.'

这种情况比较好解决，其实就和brute force可以循环i到底一样，f(i + k, j + 1) = f(i + 1, j) || f(i + 1, j - 1)   (i + 1 <= i + k <= s.length())

Case 2.b : p[i] != '.'

这种情况下，以下三个条件任意一个成立都可以：

1.f(i + 1, j) 成立， 这个情况表示星号之前的那个可以match到s[i]，也就是星号至少可以取一个之前的字符。

2.f(i + 1, j - 1)成立， 这种情况表示星号的前面第二个可以match到s[i], 也就是星号和之前的字符就当成不存在处理，也就是子串"x*"（x在这里表示任意一个字符）部分当成空字符串处理。

3.f(i, j + 1) && s[i] == s[i] && s[i - 1] == p[j - 1]成立，这种情况比较难理解。其实就是s里前一个字符和星号之前的字符相符，然后相同的字符在s[i - 1, i .... i + k]里循环下去。

根据以上的case分析。给出代码如下：

    public boolean isMatch(String s, String p) {
        if(s.length() == 0 && p.length() == 0)
            return true;
        if(p.length() == 0)
            return false;
        boolean[][] dp = new boolean[s.length() + 1][p.length() + 1];
        dp[0][0] = true;
        for(int j = 0; j < p.length(); j++){
            if(p.charAt(j) == '*'){//case 2
                dp[0][j + 1] |= j > 0 && dp[0][j - 1];
                if(j == 0)continue;
                if(p.charAt(j - 1) != '.'){//case 2b.
                    for(int i = 0; i < s.length(); i++){
                        dp[i + 1][j + 1] |= dp[i + 1][j] || dp[i + 1][j - 1] || (i > 0 && dp[i][j + 1] && s.charAt(i) == s.charAt(i - 1) && s.charAt(i - 1) == p.charAt(j - 1));
                    }
                }else{//case 2.a
                    int i = 0;
                    while(j > 0 && i < s.length() &&!dp[i + 1][j - 1] && !dp[i + 1][j])// 找到第一个匹配条件的，也就是找到第一个为真的
                        i++;
                    for(; i < s.length(); i++){
                        dp[i + 1][j + 1] = true;
                    }
                }
            }else{// case 1
                for(int i = 0; i < s.length(); i++){
                    dp[i + 1][j + 1] = dp[i][j] && (s.charAt(i) == p.charAt(j) || p.charAt(j) == '.');
                }
            }
        }
        return dp[s.length()][p.length()];
    }

下面一段code是我另外再写的，附加了很多comments的。

    public boolean isMatch(String s, String p) {
        boolean[][] subResult = new boolean[s.length() + 1][p.length() + 1];
        subResult[0][0] = true;//空集对空集当然是true了
        for(int i = 1; i < p.length(); i += 2){
            if(p.charAt(i) != '*'){
                break;
            }
            subResult[0][i + 1] = true;
        }
        for(int i = 1; i <= p.length(); i++){
            if(p.charAt(i - 1) == '*'){
//                if(i > 1 && subResult[0][i - 2])subResult[0][i] = true;
//                if(i == 1)continue;
                //这个算是一个base case，还是很有考究的。
                //基本上是可以这么理解的。
                //subResult第一维如果是0，就表示s取子集的时候取了空集
                //而这个时候，事实上就是当p[1], p[3], p[5]...p[2 * i - 1]
                //subResult[0][2 * i]都为true
                //而当其中一环断节的时候，接下来的都不为true了。
                //另外，事实上有效的输入里，i都是除以2余1的，如果全部为真的话
                if(p.charAt(i - 2) != '.'){
                    for(int j = 1; j <= s.length(); j++){
                        if(subResult[j][i - 1] || subResult[j][i - 2]){
                            subResult[j][i] = true;
                            //subResult[j + 1][i] 表示前面只取一个的时候为true
                            //也就是星号前面的字符是可以匹配当前s.charAt(j)的
                            //subResult[j + 1][i - 1]表示星号前面的字符一个都不取
                            //这种情况下就有好几种可能了。
                            //包括星号前面的前面的字符匹配
                            //星号前面的前面的字符还是星号，然后还能对当前
                            //s.charAt(j)匹配等等情况。
                        }
                        if(j > 1 && s.charAt(j - 1) == s.charAt(j - 2) && s.charAt(j - 2) == p.charAt(i - 2) && subResult[j - 1][i]){
                            subResult[j][i] = true;
                            //这个case是一个特殊的case。
                            //这个表示源字符串的某一个字符在不停重复
                            //然后这个字符和星号之前的字符是相同的
                        }
                    }
                }else{
                    //这个case就简单的多了
                    //星号前面是点号，就表示这两个字符组合可以匹配任何字符串
                    //所以就要找到第一个匹配到p字符串当前长度 - 1为真的情况
                    //因为点星组合可以匹配接下来的所有字符，所以剩下的都为真了
                    //在p到当前位置的子串的情况下
                    int j = 1;
                    while(i > 1 && j <= s.length() && !subResult[j][i - 1] && !subResult[j][i - 2])
                        j++;
                    for(; j <= s.length(); j++){
                        subResult[j][i] = true;
                    }
                }
            }else{
                //这种情况就比较好理解了，
                //只有三种情况，p.charAt(i - 1) == '.' 和 p.charAt(i - 1) == s.charAt(j - 1)是一样的，只要p.charAt(i - 2)和s.charAt(j - 2)对的上号，这里也是真
                //否则为假
                for(int j = 1; j <= s.length(); j++){
                    subResult[j][i] = subResult[j - 1][i - 1] && (p.charAt(i - 1) == s.charAt(j - 1) || p.charAt(i - 1) == '.');
                }
            }
        }
        return subResult[s.length()][p.length()];
    }

事实上上面这个算法并不能匹配brute force那边。所以我另外写了一个dp算法，跟上面那个有点相近但细节上不太一样，而且可以匹配brute force case的代码：

    public boolean isMatch(String s, String p) {
        boolean[][] subResult = new boolean[s.length() + 1][p.length() + 1];
        subResult[0][0] = true;//空集对空集当然是true了
        //这是基于空集原理更直观的base case的处理方式。
        //跟下面屏蔽掉的两行if代码是同样原理但逻辑更清晰。
        for(int i = 1; i < p.length(); i += 2){
            if(p.charAt(i) != '*'){
                break;
            }
            subResult[0][i + 1] = true;
        }
        for(int i = 1; i <= p.length(); i++){
            if(i != p.length() && p.charAt(i) == '*'){
                for(int j = 1; j <= s.length(); j++){
                    //这里实际上处理的是星号之前的字符的匹配情况
                    if(s.charAt(j - 1) == p.charAt(i - 1) || p.charAt(i - 1) == '.'){
                        subResult[j][i] |= subResult[j - 1][i - 1];
                    }
                    //这个是星号把当前字符省略的情况
                    subResult[j][i + 1] |= subResult[j][i - 1];
                    //这里是星号之前字符只取一次的情况
                    subResult[j][i + 1] |= subResult[j][i];
                    //这里其实包含了两种情况。
                    //第一个，星号之前的字符不为点，那么就只有s出现连续相同而且匹配星号之前的字符的情况，这符合了题目关于星号的描述，
                    //第二种，星号之前的字符为点，那麽就无敌了，这表示可以匹配任何字符串，所以只要出现了一个真，接下来的都是真了。
                    if(j > 1 && s.charAt(j - 1) == s.charAt(j - 2) && s.charAt(j - 1) == p.charAt(i - 1) || p.charAt(i - 1) == '.')
                        subResult[j][i + 1] |= subResult[j - 1][i + 1];
                }
                i++;
            }
            else{
                //这种情况就比较好理解了，
                //只有三种情况，p.charAt(i - 1) == '.' 和 p.charAt(i - 1) == s.charAt(j - 1)是一样的，只要p.charAt(i - 2)和s.charAt(j - 2)对的上号，这里也是真
                //否则为假
                for(int j = 1; j <= s.length(); j++){
                    subResult[j][i] = subResult[j - 1][i - 1] && (p.charAt(i - 1) == s.charAt(j - 1) || p.charAt(i - 1) == '.');
                }
            }
        }
        return subResult[s.length()][p.length()];
    }