Leetcode:Regular Expression Matching分析和实现

题目大意是要求我们实现一个简单的正则表达式全匹配判断。其中正则表达式中只包含一般字符，以及全匹配字符.和变长字符*。其中.可以匹配一个字符，而*与前一个字符相关联，x*可以被看作任意多个x（0到正无穷个）。题目要求我们判断一个字符串是否与正则表达式完全匹配，比如'.*'完全匹配''，但是'a*'不能完全匹配'b'。

---

这道题目可以用动态规划来解决。记s为待匹配的字符串，n为s的长度，p表示正则表达式字符串，m为p的长度。我们先对p进行一些预处理，将p转换为一般字符串（不包含.和*），但是其中每个字符都拥有两个布尔属性，分别是matchall （是否能匹配所有字符）和flexible （是否可以改变长度）。这可以通过类似下面的方式快速实现:

stk = empty-stack

for(i = 0; i < p.length; i++)

　　if(p[i] == '*')

　　　　stk.top.flexible = true

　　else

　　　　stk.push(p[i])

　　　　if(p[i] == '.')

　　　　　　stk.top.matchall = true

p = stk.inner-array

令dp[i][j]表示p[i...]与s[j...]是否完全匹配。dp[i][j]为真，当且仅当下述至少一个条件得到满足：

1.如果p[i].flexible是假，且p[i]能匹配s[j]，且dp[i+1][j+1]为真。

2.如果p[i].flexible是真，且dp[i+1][j]为真。

3.如果p[i].flexible是真，且p[i]能匹配s[j]，且dp[i][j+1]为真。

这三个条件的充分性非常容易验证，下面仅说明必要性。在dp[i][j]为真的情况下，若p[i]不可扩展，则显然p[i]与s[j]匹配，且p[i+1:m]与s[j+1:n]匹配，这与条件一符合。若p[i]可扩展，那么可以依据p[i]匹配0个字符和多个字符区分，匹配零个字符时，p[i+1:m]与s[j:n]匹配，匹配至少一个字符时有p[i:m]与s[j+1:n]匹配，而者分别落于条件2和条件3中。

利用以上的论述书写我们的代码：

getDp(i, j)

　　if(dp[i][j] has been initialized) //如果dp[i][j]已经被初始化过了

　　　　return dp[i][j]

　　//处理条件1

　　if(p[i].flexible == false)

　　　　dp[i][j] = (p[i].matchall || p[i] == s[j]) && getDp(i+1,j+1)

　　//处理条件2和3

　　else

　　　　flag = getDp(i + 1, j) || ((p[i].matchall || p[i] == s[j]) && getDp(i, j+1))

　　return dp[i][j]

而对于s与p是否最终完全匹配，只需要调用getDp(0, 0)即可得到结果。上述代码中没有处理越界的情况，可以在为dp分配空间时分配额外的边界空间，并在首次调用getDp之前对边界情况做判断。

上述代码的空间复杂度完全取决于dp的大小，故可以认为是O(mn)，而由于每次对getDp(i,j)的调用，如果dp[i][j]以及被初始化过了，则费用为O(1)，而完全初始化dp的费用为O(nm)，因此可以认为getDp(0,0)的时间复杂度为O(mn)。

---

最后还是老规矩，给出实现代码：

 package cn.dalt.leetcode;

 /**
  * Created by dalt on 2017/6/13.
  */
 public class RegularExpressionMatching {
     byte[][] matchStatuses;
     String text;
     int tlen;
     char[] patternBuf;
     int plen;
     int[] patternExtra;
     final int FLEXIBLE = 1 << 0;
     final int MATCH_ALL = 1 << 1;

     public boolean isMatch(String s, String p) {

         //Precalculate all needed information
         int starCount = 0;
         for (int i = 0, iBound = p.length(); i < iBound; i++) {
             if (p.charAt(i) == '*') {
                 starCount++;
             }
         }
         text = s;
         int validPatternLength = p.length() - starCount;
         patternBuf = new char[validPatternLength];
         patternExtra = new int[validPatternLength];
         int wpos = 0;
         for (int i = 0, iBound = p.length(); i < iBound; i++, wpos++) {
             char ch = p.charAt(i);
             if (ch == '*') {
                 wpos--;
                 patternExtra[wpos] |= FLEXIBLE;
             } else if (ch == '.') {
                 patternExtra[wpos] |= MATCH_ALL;
             } else {
                 patternBuf[wpos] = ch;
             }
         }
         tlen = s.length() + 1;
         plen = validPatternLength + 1;
         matchStatuses = new byte[plen][tlen];
         matchStatuses[plen - 1][tlen - 1] = 1;
         for (int i = 0, iBound = tlen - 1; i < iBound; i++) {
             matchStatuses[validPatternLength][i] = -1;
         }
         for (int i = plen - 2; i >= 0; i--) {
             matchStatuses[i][tlen - 1] = (byte) (matchStatuses[i + 1][tlen - 1] == 1 && (patternExtra[i] & FLEXIBLE) == FLEXIBLE ? 1 : -1);
         }
         return match(0, 0);
     }

     public boolean match(int i, int j) {
         if (matchStatuses[i][j] != 0) {
             return matchStatuses[i][j] == 1;
         }
         boolean flag;
         if ((patternExtra[i] & FLEXIBLE) == 0) {
             flag =  ((patternExtra[i] & MATCH_ALL) == MATCH_ALL || patternBuf[i] == text.charAt(j)) && match(i + 1, j + 1);
         } else {
             boolean matchAllFlag = (patternExtra[i] & MATCH_ALL) == MATCH_ALL;
             flag = match(i + 1, j);
             if (!flag) {
                 flag = (matchAllFlag || patternBuf[i] == text.charAt(j)) && match(i, j + 1);
             }
         }
         matchStatuses[i][j] = (byte)(flag ? 1 : -1);
         return flag;
     }
 }