LeetCode: Regular Expression Matching 解题报告

Regular Expression Matching

My Submissions

Question

 Solution 

 

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

Hide Tags Dynamic Programming Backtracking String

 

SOLUTION1:

总的来说思路是递归。

判断下一个字符是否是*：

如果不是*，则判断当前字符是否匹配。

如果是*，则因为不能确定*到底会匹配几个，在当前字符匹配的前提下，要枚举所有的情况，从假设匹配0个，1个，2个。。。只要有一种情况成功了，最终也就成功了。

我们可以从0开始，先考虑直接跳过当前2个正则字符，然后再1个，2个继续搜索下去。

如果是*，但是当前字符不匹配，则跳过两个递归。

具体的代码如下，注释写得很清楚。

ref: http://blog.csdn.net/fightforyourdream/article/details/17717873

package Algorithms;

public class IsMach {
    public static void main(String[] str) {
        //System.out.println(isMatch("aa", "aa"));
        System.out.println(isMatch("aab", "c*a*b"));
    }
    
    public static boolean isMatch(String s, String p) {
        if (s == null || p == null) {
            return false;
        }
        
        return help(s, p, 0, 0);
    }
    
    public static boolean help(String s, String p, int indexS, int indexP) {
        int pLen = p.length();
        int sLen = s.length();
        
        // 1. P结束了，这时 S也应该要结束 
        if (indexP == pLen) {
            return indexS == sLen;  
        }
        
        // 2. P 只有最后一个没有匹配
        if (indexP == pLen - 1) {
            // 必须相等，或者是p为'.'.  
            // S必须只有一个字符
            return indexS == sLen - 1 && matchChar(s, p, indexS, indexP);
        }
        
        // 以下P 至少还有2个字符.
        
        // 2. 单独匹配的情况, 如 aa, a. 类似这样
        if (p.charAt(indexP + 1) != '*') {
           if (indexS < sLen && matchChar(s, p, indexS, indexP)) {
               return help(s, p, indexS + 1, indexP + 1);  // p可以前进一格
           } else {
               return false;
           }
        }
        
        // 3. 多重匹配的情况, 如 .* or a* ,这时需要进行递归
        
        // 先直接跳过此2个正则，因为我们可以匹配空。
        if (help(s, p, indexS, indexP + 2)) {  
            return true;
        }
        
        // 匹配非空的情况,这里不可以跳过p，必须 匹配1个或是多个
        for (int i = indexS; i < sLen; i++) {
            if (!matchChar(s, p, i, indexP)) {
                return false;
            } else {
                if (help(s, p, i + 1, indexP + 2)) {
                    return true;
                }
            }
        }
        
        // 多重匹配之后，余下的字串仍然不可以匹配，则返回失败。
        return false;
    }
    
    // check if the s match p in the index.
    public static boolean matchChar(String s, String p, int indexS, int indexP) {
        return (s.charAt(indexS) == p.charAt(indexP)) || p.charAt(indexP) == '.';
    }
}

 

SOLUTION2:

稍微重写了一下，思路没有什么大的变化，但是简化了一点点：

我们只需要判断2种情况：

1. 下一个是*的情况，这个时候不需要考虑S长度。因为S为空也是可以的。

2. 下一个不是*，这个统一考虑，当前s必须留下至少一个字符，如果有，继续递归即可。

public class Solution {
    public boolean isMatch(String s, String p) {
        if (s == null || p == null) {
            return false;
        }
        
        return isMatchRec(s, p, 0, 0);
    }
    
    public boolean isMatchRec(String s, String p, int indexS, int indexP) {
        int lenS = s.length();
        int lenP = p.length();
        
        // we get to the end of the string.
        if (indexP == lenP) {
            return indexS == lenS;
        }
        
        // At lease 2 match character left
        if (indexP < lenP - 1 && p.charAt(indexP + 1) == '*') {
            // match 0;
            if (isMatchRec(s, p, indexS, indexP + 2)) {
                return true;
            }
            
            // we can match 0 or more.
            for (int i = indexS; i < lenS; i++) {
                // match once or more.
                if (!isMatchChar(s.charAt(i), p.charAt(indexP))) {
                    return false;
                }
                
                if (isMatchRec(s, p, i + 1, indexP + 2)) {
                    return true;
                }
            }
            
            // if any of them does not match, just return false.
            return false;
        }
        
        // match current character and the left string.
        return indexS < lenS 
                 && isMatchChar(s.charAt(indexS), p.charAt(indexP)) 
                 && isMatchRec(s, p, indexS + 1, indexP + 1);
    }
    
    public boolean isMatchChar(char s, char p) {
        if (p == '*') {
            return false;
        }
        
        if (s == p || p == '.') {
            return true;
        }
        
        return false;
    }
    
}

2014.12.28 Redo:

 1 public boolean isMatch(String s, String p) {
 2         if (s == null || p == null) {
 3             return false;
 4         }
 5         
 6         return dfs(s, p, 0, 0);
 7     }
 8     
 9     public boolean dfs(String s, String p, int indexS, int indexP) {
10         int lenS = s.length();
11         int lenP = p.length();
12         
13         // THE BASE CASE:
14         if (indexP >= lenP) {
15             // indexP is out of range. Then the s should also be empty.
16             return indexS >= lenS;
17         }
18         
19         // The first Case: next node is *
20         if (indexP != lenP - 1 && p.charAt(indexP + 1) == '*') {
21             // p can skip 2 node, and the S can skip 0 or more characters.
22             if (dfs(s, p, indexS, indexP + 2)) {
23                 return true;
24             }
25             
26             for (int i = indexS; i < lenS; i++) {
27                 // the char is not equal.
28                 // bug 2: Line 31: java.lang.StringIndexOutOfBoundsException: String index out of range: -1
29                 if (!isSame(s.charAt(i), p.charAt(indexP))) {
30                     return false;
31                 }
32                 
33                 if (dfs(s, p, i + 1, indexP + 2)) {
34                     return true;
35                 }
36             }
37             
38             // Not any of them can match.
39             return false;
40         } else {
41             // S should have at least one character left.
42             if (indexS >= lenS) {
43                 return false;
44             }
45             
46             if (!isSame(s.charAt(indexS), p.charAt(indexP))) {
47                 return false;
48             }
49             
50             // bug 1: forget ';'
51             return dfs(s, p, indexS + 1, indexP + 1);
52         }
53     }
54     
55     public boolean isSame(char c, char p) {
56         return p == '.' || c == p;
57     }

时间复杂度： 2^N

因为，假设P全是a*a*a*这样组成，s = aaaaaaaa 而s的每一个字符都有2种可能：与当前的a*匹配,或者与下一个a*匹配（前一个匹配空），这样假设

s有n个字符，则实际上的复杂度是2^N. 

从下是RUNTIME:

SOLUTION3:

记忆化搜索，在SOLUTION 2的基础上，加上记忆矩阵。复杂度为M*N*M。

最后一个m是遇到*时，需要遍历一次string。

// solution2: dfs + memory
    public boolean isMatch(String s, String p) {
        if (s == null || p == null) {
            return false;
        }
        
        int[][] mem = new int[s.length() + 1][p.length() + 1];
        
        // BUG 1: forget to init the memory array.
        // BUG 2: the corner is <=
        for (int i = 0; i <= s.length(); i++) {
            for (int j = 0; j <= p.length(); j++) {
                mem[i][j] = -1;
            }
        }
        
        return dfsMem(s, p, 0, 0, mem);
    }
    
    public boolean dfsMem(String s, String p, int indexS, int indexP, int[][] mem) {
        int lenS = s.length();
        int lenP = p.length();
        
        if (mem[indexS][indexP] != -1) {
            return mem[indexS][indexP] == 1;
        }
        
        // THE BASE CASE:
        if (indexP >= lenP) {
            // indexP is out of range. Then the s should also be empty.
            mem[indexS][indexP] = indexS >= lenS ? 1: 0;
            return indexS >= lenS;
        }
        
        // The first Case: next node is *
        if (indexP != lenP - 1 && p.charAt(indexP + 1) == '*') {
            // p can skip 2 node, and the S can skip 0 or more characters.
            if (dfsMem(s, p, indexS, indexP + 2, mem)) {
                mem[indexS][indexP] = 1; 
                return true;
            }
            
            for (int i = indexS; i < lenS; i++) {
                // the char is not equal.
                // bug 2: Line 31: java.lang.StringIndexOutOfBoundsException: String index out of range: -1
                if (!isSame(s.charAt(i), p.charAt(indexP))) {
                    mem[indexS][indexP] = 0;
                    return false;
                }
                
                if (dfsMem(s, p, i + 1, indexP + 2, mem)) {
                    mem[indexS][indexP] = 1;
                    return true;
                }
            }
            
            // Not any of them can match.
            mem[indexS][indexP] = 0;
            return false;
        } else {
            // S should have at least one character left.
            boolean ret =  indexS < lenS 
                && isSame(s.charAt(indexS), p.charAt(indexP))
                && dfsMem(s, p, indexS + 1, indexP + 1, mem);
            
            mem[indexS][indexP] = ret ? 1: 0;
            return ret;
        }
    }

SOLUTION 4:

DP:

D[i][j]: 表示string s中取i长度的字串，string p中取j长度字串，进行匹配。

状态转移：

1. j >= 2 && P[j - 1] = *，这时，我们可以选择匹配s中的空字串，或匹配无限个。

k: 在s中匹配的字符的个数

所以转移式是：D[i][j] = D[i - k][j - 2] && isSame(s.charAt(i - k), p.charAt(j - 2))   (k: 1-i)

                                D[i - k][j - 2]  (k = 0) 

2. p最后一个字符不是*

那么首先，s中至少还要有一个字符，然后再匹配一个字符，以及上一级也要匹配即可。

D[i][j] = i >= 1
&& isSame(s.charAt(i - 1), p.charAt(j - 1))
&& D[i - 1][j - 1];

3. j = 0;

 D[i][j] = i == 0;  (p为空，则s也是要为空才可以匹配）

以下是运行时间（LEETCODE这道题目的数据太弱了... orz)，看不出太大的区别。

// solution4: DP
    public boolean isMatch(String s, String p) {
        if (s == null || p == null) {
            return false;
        }
        
        // bug 2: should use boolean instead of int.
        boolean[][] D = new boolean[s.length() + 1][p.length() + 1];
        
        // D[i][j]: i, j, the length of String s and String p.        
        for (int i = 0; i <= s.length(); i++) {
            for (int j = 0; j <= p.length(); j++) {
                if (j == 0) {
                    // when p is empth, the s should be empty.
                    D[i][j] = i == 0;
                } else if (p.charAt(j - 1) == '*') {
                    /*
                        P has at least one node.
                    */
                    
                    // The last node in p is '*'
                    if (j < 2) {
                        // a error: there should be a character before *.
                        //return false;
                    }
                    
                    // we can match 0 characters or match more characters.
                    for (int k = 0; k <= i; k++) {
                        // BUG 3: severe! Forget to deal with the empty string!!
                        if (k != 0 && !isSame(s.charAt(i - k), p.charAt(j - 2))) {
                            D[i][j] = false;
                            break;
                        }
                        
                        if (D[i - k][j - 2]) {
                            D[i][j] = true;
                            break;
                        }
                    }
                } else {
                    D[i][j] = i >= 1 
                         && isSame(s.charAt(i - 1), p.charAt(j - 1))
                         && D[i - 1][j - 1];
                }
            }
        }
        
        return D[s.length()][p.length()];
    }

SOLUTION 5(DP): 

Date: Sep 14, 2017

简化了DP的逻辑：

D[i][j]:

1. If i == 0 => i==0

2. if (j>=2 && p.charAt(j-1) == '*') => D[i][j-2] || (i>=1 && s[i-1] == p[j-2] && D[i-1][j])

3. s[i-1] == p[j-1] && D[i-1][j-1]

class Solution {
    public boolean isMatch(String s, String p) {
        int lenS = s.length();
        int lenP = p.length();
        
        boolean[][] D = new boolean[lenS+1][lenP+1];
        
        for (int i = 0; i <= lenS; i++) {
            for (int j = 0; j <= lenP; j++) {
                if (j == 0) {
                    D[i][j] = i == 0;
                } else if (j >= 2 && p.charAt(j-1) == '*') {
                    D[i][j] = D[i][j - 2] || 
                        (i >= 1 && isEqual(s.charAt(i-1), p.charAt(j-2)) && D[i-1][j]);                    
                } else {
                    D[i][j] = i > 0 && isEqual(s.charAt(i-1), p.charAt(j-1)) && D[i-1][j-1];
                }
            }
        }
        
        return D[lenS][lenP];
    }
    
    public boolean isEqual(char s, char p) {
        return p == '.' || s == p;
    }
}

GitHub:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/string/isMatch.java 

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/string/isMatch_2014_1228.java