LeetCode-algorithms 10. Regular Expression Matching

题目：

'.' 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

思路：

因为正则表达式这个思想，很容易就让人联想到状态机，那么我们最开始的做法应该是，先识别正则表达式里面有多少个独立的表达式，如a*b*则有a* 和 b*两个状态机。

步骤1：分割正则表达式。这里我把有*号和没*号的分开，因为有*号的状态机可以跳转到自己，因此严格意义来说是两个不同的状态机。

接下来就是一个一个字符输入状态机里面看看是否匹配了。这里有几个地方需要注意的。对于单字符状态机，如“a”、“.”，跳转条件只有两个个，就是匹配，并且转到下个状态机，或者匹配失败，return false（当然对于“.”不存在匹配失败）；对于带* 号的状态机，匹配成功的跳转方向有两个个，一个是成功跳转回自己，一个是跳转到下一个字符；因此，如果把每一个状态看成一个节点，所跳转的状态为子节点，则可以把整一个匹配的流程看成一棵树，因此我的想法是遍历这棵树，以寻找成功的节点。

    对于每个状态state，储存还没匹配的字符串s'以及有可能匹配的正则表达式，表示为[s',re_list],其中re_list为分割出来的正则表达式。起始节点则储存原始字符串S和P里面所有分割好的正则表达式。使用深度优先搜索，每次pop栈的最后一个，并且把可能跳转的所有情况push到队列的尾部，直到检测到正确的节点。如果队列为空，则证明s和p不匹配。

    匹配成功有两种可能，一种是s'为最后一个字符，并且re_list为最后一个正则表达式，并且两者相匹配。另一种是s‘为最后一个字符，并且s'与re_list中第一个正则表达式匹配，除了第一个正则以外，接下来的正则表达式都带有*号。因此只要出现这两种情况，则可以return True。

   样例里面有一个特别恶心的例子s = "aaaaaaaaaaaaaaab",p="a*a*a*a*a*a*a*a*b".很明显这种情况是匹配的，但是由于有很多个带*号的正则式，这样会使得整棵树的规模很庞大，因此在分割表达式的时候，可以注意到 a*和a*a*....其实是一样的，因此可以吧重复的带*号的正则表达式合并在一起，这样在运算的时候可以减少开支。

 代码：

    

class Solution(object):
    def allZero(self,re):
        for r in re:
            if "*" not in r:
                return False
        return True
        
    def isMatch(self,s, p):
        if "*" not in p and "." not in p:
            return s == p
            
        re = []
        i = 0
        while i < len(p):
            if i < len(p) - 1 and p[i+1] == "*":
                if len(re) == 0 or p[i]+p[i+1] != re[-1]:
                    re.append(p[i]+p[i+1])
                i += 2
            else:
                re.append(p[i])
                i += 1
                
        if len(s) == 0:
            return self.allZero(re)
        already = []
        stack = []
        stack.append([s,re])
        while len(stack) != 0:
            state = stack.pop()
            s_string = state[0]
            c = s_string[0]
            s_re = state[1]
            if s_re[0][0] == "." or c == s_re[0][0]:
                next_s = state[0][1:]
                next_re = s_re[1:]
                if len(next_s)+len(next_re) == 0 or (len(next_s) == 0 and self.allZero(next_re)):
                    return True
                elif len(next_s)*len(next_re)!= 0:
                    if [next_s,next_re] not in already:
                        stack.append([next_s,next_re])
                        already.append([next_s,next_re])
                if "*" in s_re[0] and len(next_s) != 0:
                    if [next_s,s_re] not in already:
                        stack.append([next_s,s_re])
                        already.append([next_s,s_re])
            if "*" in s_re[0] and len(s_re) > 1:
                next_re = s_re[1:]
                if [s_string,next_re] not in already:
                    stack.append([s_string,next_re])
                    already.append([s_string,next_re])
        return False

结果：