LeetCode 10: Regular Expression Matching

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

解题思路

思路一：使用递归。

假设现在匹配到s的i位置，p的j位置。根据模式串的下一个字符p[j+1]是否是‘*’分两种情况讨论：
1. p[j+1]不是‘*’，只要判断s[i]和p[j]是否匹配。如果不匹配，返回false；否则，从 i + 1，j +１开始递归匹配；
2. p[j+1]是‘*’，则 p[j] 在 s 中可能被匹配0次或多次。对与每种可能的匹配，我们都需要递归匹配 s 中剩下字符串和 p[j+2:]（j+2是因为跳过当前和下一个‘*’字符），若有一个匹配成功，则返回true。

若s字符串为空，则p字符串也要为空或者间隔‘*’ （例如 p =“a*b*c*……”），否则无法匹配。若s字符串不为空，而p字符串为空，则无法匹配。

代码如下:

class Solution {
public:
    bool isMatch(string s, string p) {
        int plen = p.length();

        //模式串p为空串，若s为空则匹配成功，否则匹配失配
        if (plen == 0) return s.length() == 0;

        //模式串长度为1时
        if (plen == 1) {
            return (s.length() == 1) && (s[0] == p[0] || p[0] == '.');
        }

        //模式串长度大于等于2时
        if (p[1] != '*') {
            //模式串中p[1]不是*，则p[0]只匹配1次
            if ((s.length() > 0) && (s[0] == p[0] || p[0] == '.')) {
                //当前字符匹配，递归匹配余下部分
                return isMatch(s.substr(1, s.length() - 1), p.substr(1, plen - 1));
            }
            return false; //当前字符匹配失败
        }
        else {
            //模式串中p[1]是*，则p[0]可能被匹配0/1/2/...次
            while ((s.length() > 0) && (s[0] == p[0] || p[0] == '.')) {
                //当p[0]被匹配0/1/2/...次时，递归匹配 s 中剩下字符串和 p[j+2:]
                if (isMatch(s, p.substr(2, plen - 2))) {
                    // 若有一个匹配成功，则返回true
                    return true;
                }
                s = s.substr(1, s.length() - 1);
            }
            return isMatch(s, p.substr(2, plen - 2));
        }
    }
};

思路二：使用动态规划。动态规划的基本思想就是把计算过的历史信息记录下来，等到用到的时候就直接使用，不用重新计算。

在本题中，我们维护一个状态转移矩阵dp[p.length()+1][s.length()+1]，其中dp[i][j]表示模式串p的前i个字符（p[0], p[1], …, p[i-1]）和目标串s的前j个字符（s[0], s[1], …, s[j-1]）是否匹配。转态转移的递推公式如下：

• p[i]不是‘*’：
  dp[i][j] = dp[i-1][j-1] && (p[i - 1] == s[j - 1] || p[i - 1] == ‘.’);
• p[i]是‘*’：
  dp[i][j] = dp[i+1][j] = ((dp[i][j-1] && (p[i-1] == s[j-1] || p[i-1] == ‘.’)) || dp[i-1][j]);

按行填充转态转移矩阵，即外层循环扫描p，内层循环扫s。

代码如下：

class Solution {
public:
    bool isMatch(string s, string p) {
        int slen = s.length(), plen = p.length(), i, j;  

        /*
         * dp[i][j]代表模式串p的前i个字符和目标串s的前j个字符是否匹配
         * 注意dp的实际维度为[p.length()+1, s.length()+1]
         */
        bool dp[500][500];  
        memset(dp,false, sizeof(dp));  

        // 空字符串和空字符串匹配
        dp[0][0] = true;  
        for (i = 1; i <= plen; ++i) {  
            // 按行填充状态矩阵的顺序
            if (p[i] == '*') { 
                dp[i+1][0] = dp[i][0] = dp[i-1][0];  
                for (j = 1; j <= slen; ++j) {
                    dp[i+1][j] = dp[i][j] = ((dp[i][j-1] && (p[i-1] == s[j-1] || p[i-1] == '.')) || dp[i-1][j]);  
                }
                ++i;          
            }  
            else {
                // p[i]不是'*'，注意dp[i][]表示p的前i个字符（p[0],p[1],...,p[i-1]）和s的匹配情况
                for (j = 1; j <= slen; ++j) {  
                    dp[i][j] = dp[i-1][j-1] && (p[i - 1] == s[j - 1] || p[i - 1] == '.');
                }
            }
        }  
        return dp[plen][slen]; 
    }
};