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];     }};