[LeetCode 10] 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)

Example

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

For s[0 ~ i] and p[0 ~ j], we have the following cases.

1. s[i] == p[j] or p[j] == '.' ,   reduce the problem to s[0 ~ i - 1] and p[0 ~ j - 1];

2. p[j] == '*', 

　a.　　s[i] == p[j - 1] or p[j - 1] == '.'   : reduce to s[0 ~ i] and p[0 ~ j - 2] for 0 occurence of p[j - 1];  or reduce to s[0 ~ i - 1] and p[0 ~ j] for 1 occurence of p[j - 1].

    b.　　s[i] != p[j - 1] :  reduce to s[0 ~ i] and p[0 ~ j - 2] for 0 occurence of p[j - 1].

3. all other cases s and p do not match. 

　

We can solve this problem based the above analysis both recursively and by dynamic programming. 

Solution 1. Recursion

public class RegularExpressionMatching {
    public boolean isMatchRecursion(String str, String pattern) {
        if(str == null || pattern == null) {
            return false;
        }
        String newPattern = pattern.replaceAll("(\*){2,}", "*"); 
        return matchHelper(str, str.length() - 1, newPattern, newPattern.length() - 1);
    }
    private boolean matchHelper(String str, int idx1, String pattern, int idx2) {
        if(idx1 < 0 && idx2 < 0 || idx1 < 0 && idx2 <= 1 && pattern.charAt(idx2) == '*') {
            return true;
        }
        else if(idx1 < 0 && idx2 >= 0 || idx1 >= 0 && idx2 < 0) {
            return false;
        }
        if(pattern.charAt(idx2) == '.' || str.charAt(idx1) == pattern.charAt(idx2)) {
            return matchHelper(str, idx1 - 1, pattern, idx2 - 1);
        }
        else if(pattern.charAt(idx2) == '*') {
            if(idx2 > 0 && (pattern.charAt(idx2 - 1) == str.charAt(idx1) || pattern.charAt(idx2 - 1) == '.')) {
                return matchHelper(str, idx1, pattern, idx2 - 2) || matchHelper(str, idx1 - 1, pattern, idx2);
            }
            else {
                return matchHelper(str, idx1, pattern, idx2 - 2);
            }
        }
        return false;
    }
    public static void main(String[] args) {
        RegularExpressionMatching test = new RegularExpressionMatching();
        System.out.println(test.isMatchRecursion("", ""));    //true
        System.out.println(test.isMatchRecursion("", "*"));    //true
        System.out.println(test.isMatchRecursion("aa", "a"));    //false
        System.out.println(test.isMatchRecursion("aa", "aa"));    //true
        System.out.println(test.isMatchRecursion("aaa", "aa"));    //false
        System.out.println(test.isMatchRecursion("aa", "*"));    //false
        System.out.println(test.isMatchRecursion("aa", "**"));    //false
        System.out.println(test.isMatchRecursion("aa", "a*"));    //true
        System.out.println(test.isMatchRecursion("ab", ".*"));    //true
        System.out.println(test.isMatchRecursion("aab", "*a.b"));    //true        
    }
}

Solution 2. Dynamic Programming 

Initialization: 

T[0][0] = true;  When both s and p are empty string, the match result should return true.

When s is empty, there is also another case of p that matches the empty string.  If each letter a-z or . is followed by *, like a*b*c*, then taking 0 occurence of each letter matches empty string.

public boolean isMatchDp(String str, String pattern) {
    if(str == null || pattern == null) {
        return false;
    }
    String newPattern = pattern.replaceAll("(\*){2,}", "*"); 
    boolean[][] T = new boolean[str.length() + 1][newPattern.length() + 1];
    T[0][0] = true;
    for(int i = 1; i <= newPattern.length(); i++) {
        if(i == 1 && newPattern.charAt(i - 1) == '*') {
            T[0][i] = true;
        }
        else if(newPattern.charAt(i - 1) == '*') {
            T[0][i] = T[0][i - 2];
        }
    }
    for(int i = 1; i <= str.length(); i++) {
        for(int j = 1; j <= newPattern.length(); j++) {
            if(str.charAt(i - 1) == newPattern.charAt(j - 1) || newPattern.charAt(j - 1) == '.') {
                T[i][j] = T[i - 1][j - 1];
            }
            else if(newPattern.charAt(j - 1) == '*') {
                if(j == 1) {
                    T[i][j] = false;
                }
                else {
                    T[i][j] = T[i][j - 2];
                    if(str.charAt(i - 1) == newPattern.charAt(j - 2) || newPattern.charAt(j - 2) == '.'){
                        T[i][j] |= T[i - 1][j];
                    }
                }
            }
            else {
                T[i][j] = false;
            }
        }
    }
    return T[str.length()][newPattern.length()];
}

Related Problems 

Wildcard Matching