10. Regular Expression Matching

方法：DP->leetcode 44 wildcard matching

本题是DP里较难理解的一类题
本题难点在于如何处理号，dp 是常用的最优算法。难点在于如何通过dp来表示 * 的处理方法。
a：有三种用法：
1 a* = “”, 不用前面的字母
2 a* = a, 用1次前面的字母
3 a* = aaa…, 用n次前面的字母

第1步：初始化

第2步：修改初始化pattern

因为空字符串和空字符串一定匹配，作为设定条件，如果规定不匹配，无法使用dp, 按照常识，是匹配的。对于text和空，只要text有字符，一定为假。但是如果，pattern中有 * 那么可以用 *的第一种方法，即为使用0 次前面的字母。这里字符串和dp相差一位。因为dp补充了一位空字符。

if p[i-1] == "*" and dp[0][i - 2]:
    dp[0][i] = True

第3步：递归

这里用到至上而下的递归方法，递归的难点在于如何把*的功能转化到dp上。
1 遇到点的处理，很好理解，可以把点当作任何一个字母，如果当前的两个字母相等，那么只需看他们前面的各自字母。

if p[j-1] == "." or p[j-1] == s[i-1]:
    dp[i][j] = dp[i-1][j-1]

2 遇到 * 号，首先看 * 的第一中方法，即为使用0次，此时用到

dp[i][j] = dp[i][j-2]
此时不需要看他们各自前面的字母是否相等，因为没有使用*前面的字母。所以没有条件。

如果要使用*前面的字母，那么有两种情况，使用一次或多次

 if dp[i][j-2] == False and (p[j-2] == s[i-1] or p[j-2]== "."):
    dp[i][j] = dp[i][j-1] or dp[i-1][j]

因为使用了*，所以需要判断前和text字母前的字母是否相等，如果相等，那么使用一次时，dp[i][j] = dp[i][j-1]，
使用多次时dp[i][j] = dp[i-1][j]，难点在于使用多次的理解。
如果使用一次情况 2： a* = a, 用1次前面的字母
如果使用多次次情况 3： a* = aaa…, 用n次前面的字母，
因为dp上*自能暂用一个位置，要想满足多次，可以用到你想思维，如果比较a * = aa，那么可以比较a * = a是否相等，用为a * 可以表示无限多a,那么如果a * = a， a * 必然等于 aa或aaa…

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        # use dp
        dp = [[False for j in range(len(p) + 1)] for i in range(len(s) + 1)]
        dp[0][0] = True
        # for a*b* cases
        for i in range(1, len(p) + 1):
            if p[i-1] == "*" and dp[0][i - 2]:
                dp[0][i] = True
        
        for i in range(1, len(s) + 1):
            for j in range(1, len(p) + 1):
                if p[j-1] == "." or p[j-1] == s[i-1]:
                    dp[i][j] = dp[i-1][j-1]
                elif p[j-1] == "*":
                    dp[i][j] = dp[i][j-2]
                    if dp[i][j-2] == False and (p[j-2] == s[i-1] or p[j-2]== "."):
                        dp[i][j] = dp[i][j-1] or dp[i-1][j]
                else:
                    dp[i][j] = False
        return dp[-1][-1]

如果遇到*，
比如：p1: a和 p2: aa*, 那么此时当p2指向时，如果向左移动2，那么检查a和a是否相等，如果相等那么dp[i][j] = dp[i][j-2] = True，就不用再做处理，如果不为真，
检查使a为一个或多个的情况
比如：p1: ba和 p2: ba*， 满足dp[i][j] = dp[i][j-1], ba=ba
比如：p1: baaaa和 p2: ba*， 满足dp[i][j] = dp[i-1][j],
baaa和ba*, -> baa和ba* -> ba和ba*, 直到满足条件，而baaa和ba*, -> baa和ba* -> ba和ba这些已经存在DP里，只需要看baaa和ba，故而满足dp[i][j] = dp[i-1][j]就可以了。
当前代码有太多的重复：

优化后：

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        dp = [[False for j in range(len(p) + 1)] for i in range(len(s) + 1)]
        dp[0][0] = True
        for j in range(2, len(p) + 1):
            if p[j-1] == "*" and dp[0][j-2]:
                dp[0][j] = True
        
        for i in range(1, len(s) + 1):
            for j in range(1, len(p) + 1):
                if p[j-1] == s[i-1] or p[j-1] == ".":
                    dp[i][j] = dp[i-1][j-1]
                elif p[j-1] == "*":
                    if dp[i][j-2]:
                        dp[i][j] = dp[i][j-2]
                    elif p[j-2] == s[i-1] or p[j-2] == ".":
                        dp[i][j] = dp[i][j-1] or dp[i-1][j]
        return dp[-1][-1]