PigyChan_LeetCode 剑指 Offer 19. 正则表达式匹配

剑指 Offer 19. 正则表达式匹配

难度困难

请实现一个函数用来匹配包含’. ‘和’ * ‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’ * '表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。

示例 1:
输入:s = "aa"p = “a”
输出: false
解释: “a” 无法匹配 “aa” 整个字符串。

示例 2:
输入:s = "aa"p = “a*”
输出: true
解释: 因为 ’ * ’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。

示例 3:
输入:s = "ab"p = ". * "
输出: true
解释: ". * " 表示可匹配零个或多个（’ * ‘）任意字符（’.’）。

示例 4:
输入:s = "aab"p = “cab”
输出: true
解释: 因为 ’ * ’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。

示例 5:
输入:s = “mississippi"p = " mis * is * p*.”
输出: false
* s 可能为空，且只包含从 a-z 的小写字母。
* p 可能为空，且只包含从 a-z 的小写字母以及字符 . 和 *，无连续的 ’ * '。

思路：

（一）碰到’.‘的处理
（1）’.‘可以表示所有字符，所以无论当前谁与其配对，都能成功
（2）继续推测下一个字符
（二）碰到’ * ‘的处理
（1）因为’ * ‘表示的是它前面的若干字符可为任意数量，所以需要得到当前字符的下一个字符，以判断当前字符是不是"可长可短"
（2）后面跟着’ * '的字符的行为可分为两种
1. 向后移动两格，意味着该字符的数量为0
2. 一动不动，意味着该字符要被多次使用

废案1：自己一开始的做法

      class Solution {
      public:
          bool isMatch(string s, string p) {
              if (s.empty() || p.empty()) return false;
              int indexS = 0;
              int indexP = 0;
              while (indexS < s.size()) {
                  //p当前字符的下一个字符不是'*'
                  if ((indexP + 1 < p.size() && p[indexP + 1] != '*') || indexP + 1  == p.size()) {
                      //当前对应字符匹配，继续向后匹配
                      if (s[indexS] == p[indexP] || p[indexP] == '.') {
                          ++indexS;
                          ++indexP;
                      }
                      else {
                          return false;
                      }
                  }
                  //p当前字符的下一个字符是'*'
                  else if (indexP + 1 < p.size() && p[indexP + 1] == '*') {
                      //当'.'和'*'组合在一起，"无敌"，
                      if (p[indexP] == '.') indexS;
                      //字符匹配，p当前的特殊字符可继续使用
                      if (s[indexS] == p[indexP]) {
                          ++indexS;
                      }
                      //字符不匹配，p必须向后移动两格，以舍弃那个带'*'的特殊字符
                      else {
                          indexP += 2;
                      }
                  }
              }
          }
      };

废案2：参考《剑指offer》上的代码

  class Solution {
      public:
          bool isMatch(string s, string p) {
              return matchCore(s, p, 0, 0);
          }
          bool matchCore(const string& s,const string& p,int idxOfS, int idxOfP) {
              if (idxOfS == s.size()  && idxOfP == p.size() ) return true;
              if (idxOfS != s.size()  && idxOfP == p.size() ) return false;
              //如果p当前字符的后一个字符为'*'
              if (p[idxOfP + 1] == '*') {
                  //此时s和p的对应字符匹配时，可能采取的所有行为
                  if (p[idxOfP] == s[idxOfS] || (p[idxOfP] == '.' && idxOfS !=  s.size() )) {
                          //p的这个特殊字符只成功用了一次
                      return matchCore(s, p, idxOfS + 1, idxOfP + 2)
                          //p的当前字符要被多次使用
                          || matchCore(s, p, idxOfS + 1, idxOfP)
                          //p不使用这个特殊的字符
                          || matchCore(s, p, idxOfS, idxOfP + 2);
                  }
                  else {
                      //不匹配，无法使用这个特殊字符
                      return matchCore(s, p, idxOfS, idxOfP + 2);
                  }
              }
              //如果p当前字符的后一个字符不为'*'
              if (s[idxOfS] == p[idxOfP] || (p[idxOfP] == '.' && idxOfS != s.size()  ))
                  return matchCore(s, p, idxOfS + 1, idxOfP + 1);
              return false;
          }
      };

书上的代码时间效率不太行啊

思路：

一，从后往前看，字符串A和模式串B有如下几种情况，设A的长度为n，设B的长度为m
（1）A[n-1] == B[n-1]，当前两对应字符匹配，继续看下一组字符，即A[n-2]和B[m-2]
（2）B[n-1] == ’ . '，当前两对应字符匹配，继续看下一组字符，即A[n-2]和B[m-2]
（3）B[n-1] == ’ * '，这意味着B[n-2]是个有着特殊行为的字符，它可能的行为如下：
1.
B[n-2]能被多次使用，即意味着如果A[n-1] == B[n-2]，A中的字符转为下一个A[n-2]，而B中的B[n-2]则可以继续使用
2.
B[n-2]为0个，即意味着B[n-2]与B[n-1]作废，直接拿B[n-3]与A的当前字符进行下一轮比较
特殊输入：空串
（1）空A与空B，两者匹配
（2）空A与非空B，结果需要进一步考虑B的结构来判断
（3）非空A与空B，两者必不能匹配
（4）非空A与非空B，直接进入比较

代码：

      class Solution {
      public:
          bool isMatch(string s, string p) {
              //处理输入值特殊情况
              if (s.empty() && p.empty())   return true;
              if (!s.empty() && p.empty())    return false;
              
              //从后往前匹配
              return MatchCore(s, p, s.size() - 1, p.size() - 1);
          }


          bool MatchCore(const string& A, const string& B, int idxA, int idxB) {
              //递归结束条件
              if (idxA == -1 && idxB == -1) return true;
              if (idxA != -1 && idxB == -1) return false;


              //B的当前字符是'*'时
              if (B[idxB] == '*') {
                  //'*'前的字符可以多次使用的情况，其中还要考虑刻意pass'*'前的字符的情况
                  if (idxA >= 0 && (A[idxA] == B[idxB - 1] || B[idxB - 1] == '.'))
                      return MatchCore(A, B, idxA - 1, idxB)
                      || MatchCore(A, B, idxA, idxB - 2);


                  //'*'前的字符必须pass的情况
                  if (idxA == -1 || (A[idxA] != B[idxB - 1] && B[idxB - 1] != '.')) {
                      return MatchCore(A, B, idxA, idxB - 2);
                  }
              }
              //B的当前字符不是'*'时
              else {
                  //如果匹配
                  if (idxA >= 0 && (A[idxA] == B[idxB] || B[idxB] == '.'))
                      return MatchCore(A, B, idxA - 1, idxB - 1);
              }


              return false;
          }
      };

卧槽！！！第一次达到这么高的成绩！我爽了