No.010：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).

官方难度：

Hard

翻译：

实现正则表达式匹配字符串，支持特殊符号“.”和“*”。

“.”匹配任意单个字符串。

“*”匹配0至人任意多个“*”之前的字符串。

算法必须满足任意的正则表达式匹配。

例子：

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
isMatch("aab", ".*a") → false
isMatch("aab", ".*ab") → true

1. 每次我都将入参检查这一步放到最后，只是提醒一下，而这次却要在一开始就提起这一点。原因很简单：正则表达式匹配算法，是一定会使用递归的，在递归算法中，执行入参检查是一件非常不智的事情，因为在递归进入方法时，是一定符合入参规范的，多余的检查会影响效率。这时候合适的做法有2个：在进入方法前检查入参；或者将递归方法独立出来。这里选择第二种做法。
2. 基本的思想是：从头开始，消去将匹配成功的部分，不断循环直到字符串的长度为0。循环期间，只要出现不匹配的情况，直接返回false；或是在字符串还有剩余的情况下，正则表达式长度为0，返回false。
3. 在进入循环之前，思考一个问题：有没有什么情况，可以不进入循环，直接判断匹配失败？实际上，在只有“.”和“*”的正则表达式，仅有“*”这个特殊符号会影响正则表达式匹配的长度。这样一来，可以从后往前遍历，直到在正则表达式中遇到“*”，只要出现不匹配，整个算法不匹配。
4. 从前向后遍历，只有当第二个字符是“*”的时候，考虑特殊情况，否则单个字符匹配。
5. 第二个字符是“*”，基本的思想是返回一个“*”匹配的长度。分2种情况：正常字符+“*”和“.*”。
6. 先讨论“.*”的特殊情况。因为“.*”能匹配任意字符组合的任意长度字符串。这种情况下，讨论“*”匹配的长度是不现实的。这种时候就需要递归了。举一个简单的例子：“.*dd*”匹配“acdadd”，无法确定“.*”匹配的长度是2、4、5还是6。实际上“*”匹配长度是4或者6的时候，整个正则表达式都能匹配成功。此时，合理的做法是，考虑“.*”之后的正则表达式“dd*”，先判断这个正则表达式能否匹配空字符串，然后依次拿这个正则表达式去匹配“acdadd”、“cdadd”、……、“dd”、“d”。如果全都不匹配，那么整个不匹配。只要出现一个匹配，整个匹配。
7. 然后考虑正常字符+“*”的情况，看似简单，但其实是比“.*”的思考更加复杂。
8. 先考虑正则表达式长度为2的情况，即只有正常字符+“*”，直接返回“*”匹配的长度。
9. 在考虑正则表达式长度为3的情况，“*”前面和后面的字符的匹配情况，以及字符串最后一个字符和“*”后面的字符的匹配情况（这种情况不匹配，直接整个不匹配），满足这2个条件，会使“*”的匹配长度-1（得到的匹配长度小于0时，做0处理）。如“a*.”中，“a”可以匹配“.”，匹配“a”和“aa”时，“a*”的匹配长度分别是0和1。
10. 然后考虑正则表达式长度大于3的情况，根据第4个字符是否为“*”，又可以分2种情况。
11. 第4个字符是“*”的情况下，根据第3个字符还可以分为3种情况。第一种情况，如“a*.*b”的匹配能力和“.*b”是等价的。“a*”的意义在于，尽可能消去字符串中开头的“a”的个数，从而减少之后“.*”的循环次数；第二种情况，如“a*a*b”，等价于“a*b”，消去一个“a*”进行递归；第三种情况，如“a*b*c”，这时要先考虑“b*”中第二个“*”的匹配情况。获取字符串中，第一个不是“a”的字符串，如果不是“b”，表明“b*”的匹配个数为0，消去“b*”递归。不然（包括原字符串全是“a”的情况），返回“a*”的匹配个数。
12. 第4个字符不是“*”的情况下，根据第三个字符也能分为3种情况。
13. 第一种情况，如“a*ba”，正常返回“a*”的匹配个数。
14. 第二种情况，如“a*aab”，计算正则表达式“*”之后“a”的个数count，以及字符串“a”开头的个数length。根据正则表达式“a*”之后下一个不是“a”的字符，分3种情况。第一种，没有或不是“.”或不是“*”，返回“a*”的匹配长度；第二种，“.”，如“a*aaa.b”和“aaaacb”，消去count的值（count>length直接匹配失败），递归，等价于“a*.b”和“acb”的匹配；第三种，“*”，先将count-1，之后与第二种的操作基本相同。
15. 最后一种情况：第3个字符是“.”且第4个字符不是“*”，如“a*.b..*”，但是由于第5个及之后的字符是不确定的（“*”和“.”），不能确定“a*”的具体匹配长度。与“.*”的处理类似，拿之后的正则表达式去匹配“a*”的所有可能性。如字符串为“aabcde”，依次拿“.*b..*”去匹配“aabcde”、“abcde”、“bcde”，期间只要出现一次匹配，整个匹配成功，否则整个匹配失败。
16. 当字符串匹配完成，但是正则表达式还有剩余，检查剩余的正则表达式能否匹配空字符串。

解题代码：

 public static boolean isMatch(String s, String p) {
         // 递归方法不适用入参检查
         if (s == null || p == null) {
             throw new IllegalArgumentException("Input error");
         }
         // 循环匹配最后一位，若匹配失败，直接匹配失败
         while (p.length() > 0 && s.length() > 0) {
             if (p.substring(p.length() - 1).equals("*")) {
                 break;
             } else {
                 if (singleMatch(s.charAt(s.length() - 1), p.charAt(p.length() - 1))) {
                     p = p.substring(0, p.length() - 1);
                     s = s.substring(0, s.length() - 1);
                 } else {
                     return false;
                 }
             }
         }
         return isMatchTrue(s, p);
     }

     private static boolean isMatchTrue(String s, String p) {
         // 待处理的正则
         String pDeal;
         // 消去的字符串长度
         int sReduce;
         // 以字符串为主体，匹配正则
         while (s.length() > 0) {
             // 正则长度为0
             if (p.length() == 0) {
                 return false;
             }
             if (p.length() > 1 && p.charAt(1) == '*') {
                 // 第二个字符：*
                 pDeal = p.substring(0, 2);
                 sReduce = starMatch(s, p);
                 // 在内部方法中，已经通过递归得出结果
                 if (sReduce == -1) {
                     return true;
                 } else if (sReduce == -2) {
                     return false;
                 }
             } else {
                 // 单字符匹配
                 pDeal = p.substring(0, 1);
                 if (!singleMatch(s.charAt(0), p.charAt(0))) {
                     return false;
                 }
                 sReduce = 1;
             }
             // 消去字符串
             s = s.substring(sReduce);
             p = p.substring(pDeal.length());
         }
         // 字符串解析完成，但正则还有剩余
         if (!regularEqualsNull(p)) {
             return false;
         }
         return true;
     }

     // 普通字符+*，返回*匹配的长度
     private static int starMatchNormal(String s, String p) {
         char pBeforeStar = p.charAt(0);
         // 正则长度：2
         if (p.length() == 2) {
             return getLength(s, pBeforeStar);
         }
         char pAfterStar = p.charAt(2);
         // 正则长度：3
         if (p.length() == 3) {
             int l = getLength(s, pBeforeStar);
             // 字符串s的最后一个字符，会影响*匹配长度
             if (singleMatch(s.charAt(s.length() - 1), pAfterStar)) {
                 if (singleMatch(pBeforeStar, pAfterStar)) {
                     l--;
                 }
             } else {
                 // 最后一个字符不匹配，整体不匹配
                 return -2;
             }
             return l < 0 ? 0 : l;
         }
         // 正则第四个字符：*
         if (p.charAt(3) == '*') {
             // 如(aaabcd,a*.*d)
             // a*是否存在，不影响整体的匹配结果
             // 但是可以尽可能消去字符串s中，a起始的个数，减小.*匹配的负担
             if (pAfterStar == '.') {
                 return getLength(s, pBeforeStar);
             }
             // 如a*a*，与a*等价
             if (pAfterStar == pBeforeStar) {
                 return isMatchTrue(s, p.substring(2)) ? -1 : -2;
             }
             // 余下情况，如a*b*，考虑b*匹配长度
             if (pAfterStar != notXFromStart(s, pBeforeStar)) {
                 // b*匹配长度：0
                 return isMatchTrue(s, p.substring(0, 2) + p.substring(4)) ? -1 : -2;
             }
             // b*匹配长度大于1；或字符串全部由a组成
             return getLength(s, pBeforeStar);
         } else {
             // 如a*.
             // 无法确定*匹配的具体长度
             if (p.charAt(2) == '.') {
                 // a*之后，所有的正则
                 String pAfterPoint = p.substring(2);
                 // 匹配字符串中，*所有可能性
                 int posibility = getLength(s, pBeforeStar) + 1;
                 for (int i = 0; i < posibility; i++) {
                     if (isMatchTrue(s, pAfterPoint)) {
                         return -1;
                     }
                     if (s.length() == 0) {
                         return -2;
                     }
                     s = s.substring(1);
                 }
                 return -2;
             }
             // 如a*a
             if (p.charAt(2) == pBeforeStar) {
                 // a*之后a的个数
                 int count = 1;
                 for (int i = 3; i < p.length(); i++) {
                     if (p.charAt(i) == pBeforeStar) {
                         count++;
                     } else {
                         break;
                     }
                 }
                 // 如a*aaaab的b
                 Character after = count == p.length() - 2 ? null : p.charAt(count + 2);
                 int l = getLength(s, pBeforeStar);
                 if (after == null || !(after.equals('.') || after.equals('*'))) {
                     // 类似a*aaab一定不匹配aab
                     if (count > l) {
                         return -2;
                     }
                     return l - count;
                 }
                 // 如(a*aaa.b,aaaacb)，count=3
                 if (after.equals('.')) {
                     if (count > l) {
                         return -2;
                     }
                     // 等价(a*.b,acb)
                     s = s.substring(count);
                     p = p.substring(0, 2) + p.substring(2 + count);
                     if (isMatchTrue(s, p)) {
                         return -1;
                     }
                     return -2;
                 }
                 // 如(a*aaa*b,aaaacb)，count=2
                 // 等价(a*b,aacb)
                 if (after.equals('*')) {
                     count--;
                     if (count > l) {
                         return -2;
                     }
                     s = s.substring(count);
                     p = p.substring(2 + count);
                     if (isMatchTrue(s, p)) {
                         return -1;
                     }
                     return -2;
                 }
             }
             // 余下情况，如a*ba
             return getLength(s, pBeforeStar);
         }
     }

     // 返回*匹配长度
     private static int starMatch(String s, String p) {
         if (p.charAt(0) == '.') {
             // .*
             p = p.substring(2);
             // .*之后的正则，如果可以匹配空字符串，直接匹配成功
             if (regularEqualsNull(p)) {
                 return -1;
             }
             // 用余下的正则，循环递归
             for (int i = 0; i < s.length(); i++) {
                 String sAfter = s.substring(i);
                 if (isMatchTrue(sAfter, p)) {
                     return -1;
                 }
             }
             // 余下的都不成功，表示整个不匹配
             return -2;
         } else {
             return starMatchNormal(s, p);
         }
     }

     // 单个字符匹配
     private static boolean singleMatch(char s, char p) {
         if (p == '.' || p == s) {
             return true;
         }
         return false;
     }

     // 一个可以表示为空字符串的正则表达式
     private static boolean regularEqualsNull(String p) {
         if (p.length() % 2 == 1) {
             return false;
         }
         while (p.length() > 0) {
             if (p.charAt(1) != '*') {
                 return false;
             }
             p = p.substring(2);
         }
         return true;
     }

     // 在字符串s中，第一个不是x的字符
     private static char notXFromStart(String s, char x) {
         for (int i = 0; i < s.length(); i++) {
             if (s.charAt(i) != x) {
                 return s.charAt(i);
             }
         }
         // s全部由x组成
         return x;
     }

     // 字符串s中，以pBeforeStar开头的个数
     private static int getLength(String s, char pBeforeStar) {
         int l = 0;
         for (int i = 0; i < s.length(); i++) {
             if (s.charAt(i) == pBeforeStar) {
                 l++;
             } else {
                 break;
             }
         }
         return l;
     }

isMatch

相关链接：

https://leetcode.com/problems/regular-expression-matching/

https://github.com/Gerrard-Feng/LeetCode/blob/master/LeetCode/src/com/gerrard/algorithm/hard/Q010.java

PS：如有不正确或提高效率的方法，欢迎留言，谢谢！