LeetCode OJ --问题与解答 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

准备1

---

1 面试时候碰到此类问题，先确定是否有非法情况：

1.1  空字符串

1.2 源字符串出现意想不到的字符 A . *等

1.3 pattern 出现非规则情况 **等

2 一般这个问题考的是思路，所以非法情况面试官会回答你过滤掉。可以专心考虑逻辑问题。

思路1

---

1 第一次碰到这个问题，我想很少有人能够得到完美的思路和代码

2 http://leetcode.com/2011/09/regular-expression-matching.html 这个网站的思路很好，我大致从重要部分翻译一下

3 提示：仔细想想碰到*你怎么办？会匹配前面0个或多个。但具体多少次？不知道？恩，这时候应该想到递归是你的好朋友。

4 解决办法：

4.1 为什么不能一个字符一个字符去匹配？ 因为* 会捣乱

4.2 那么自然就想到贪婪算法。把前面的字符尽可能多的去匹配如何？如例子：s = “abbbc”, p = “ab*c”.可以成功。 但是看这个例子：s = “abbc”, p = “ab*bbc”, b* 会把s的‘bb’都匹配完，可是之后就没法匹配了。贪婪算法在这里失败了。

4.3 有人马上想到对于前一个失败的列子，是否可以统计s中b出现了几次，然后和*后的b进行比较，来进行算法。但是这个问题也有反例：s = “abcbcd”, p = “a.*c.*d”

4.4 我们需要一个回退机制，当我们匹配失败的时候，我们回到最后一个成功匹配的状态，然后用*匹配s中更多的字符，这个很自然就想到递归。

4.5 递归很优美的就分到了如下两个状态：

4.5.1 如果p中下一个不是*，那么必须匹配目前这个字符。然后再匹配接下去的字符串。

4.5.2 如果p中下一个是* ，那么我们暴力破解。匹配目前的字符0次，1次，2次。。。直到不能匹配。

4.6 基准条件很重要，留给读者自己思考。

代码 1

---

public class Solution {
    public boolean isMatch(String s, String p) {
        if(p.length()==0 ){
            return s.length()==0;
        }
        if(p.length()==1 || p.charAt(1)!='*'){
            if(s.length()==0){
                return false;
            }
            if(p.charAt(0)=='.' || p.charAt(0) ==s.charAt(0)){
                return isMatch(s.substring(1),p.substring(1));
            }
            return false;
        }
        while(s.length()!=0 && (s.charAt(0)==p.charAt(0)||p.charAt(0)=='.')){
            if(isMatch(s,p.substring(2))){
                return true;
            }
            s = s.substring(1);
        }
        return isMatch(s,p.substring(2));
    }
}

1 当pattern 结束的时候，源字符串如果结束，true; 没有结束 false。反过来写就不可以，因为当源字符串为空的时候，p为a*也可以。

2 当pattern有下一个字符，并且下一个字符不为*的时候，我们很开心，按照正常的对应来走。

3 之后就是pattern下一个字符为*的时候的情况：

3.1 当源字符串不为空，且源字符串的当前字符和pattern当前字符匹配或者pattern当前字符为. 的时候

3.1.1 先判断如果不要这*是否能够和源字符串匹配，如果匹配，直接为true

3.1.2 如果不匹配，那么我们去掉一个源字符串的当前字符，pattern不变，继续走。

3.2 剩下的情况：

3.2.1 源字符串为空字符

3.2.2 源字符串当前字符和*前一个字符不匹配

那么我们都跳过pattern的当前字符和*，新的pattern来匹配源字符串。

思路2

---

1 递归都可以用迭代来实现，http://blog.csdn.net/a83610312/article/details/9750655这篇文章特别好

2 用DP+数组记录的方式。

代码2

---

public class Solution {
    public boolean isMatch(String s, String p) {
        if(p.length()==0 ){
            return s.length()==0;
        }
        int slength = s.length();
        int plength = p.length();
        
        boolean [][] record = new boolean[slength+1][plength+1];
        
        record[0][0]=true;
        for(int j=2;j<=plength;j++){
            if(p.charAt(j-1) =='*'){
                record[0][j]=record[0][j-2];
            }
        }
        
        for(int i=1;i<=slength;i++){
            for(int j=1;j<=plength;j++){
                char cur = p.charAt(j-1);
                if(cur == '.'){
                    record[i][j]=record[i-1][j-1];
                }
                else if(cur == '*'){
                    record[i][j]=record[i][j-1] || record[i][j-2] ||(record[i-1][j]&&(s.charAt(i-1)==p.charAt(j-2)|| p.charAt(j-2)=='.' ));
                    
                }
                else{
                    record[i][j]=record[i-1][j-1] && s.charAt(i-1)==p.charAt(j-1);
                }
            }
        }
        
        
        return record[slength][plength];
    }
}