LeetCode 0010

原题链接：

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

题意理解

就是求一个正则表达式的匹配。显然，这时候掏出Java的Pattern就好了。（

如果是编译原理的话，那么考虑一下RE⇒NFA⇒DFA⇒DFAo⇒program

可以参考我的这篇文章：

https://blog.csdn.net/qq_33230935/article/details/78209950

但是对于这条题目来说，实际上是只有两种特殊情况。假设只有’.’，那这题目简直傻疯了。加了’*’之后，情况要稍微复杂一点，主要是不知道匹配到什么时候结束的问题。举个例子，text是”aaaa”，而pattern”a*”，”a*a”都是可以的。。。可以考虑参考我的这篇文章：https://blog.csdn.net/qq_33230935/article/details/78253585

然而实际上，我们是可以通过在第二篇文章基础上小规模改写程序达到不出现栈溢出的问题的效果的，于是肯定是可以通过递归写的，但是不保证时间不会超。当然我们已经知道了可以用递归写，在这个过程中可能有大量的重复操作，那么显然，是可以通过dp来改写的，但是到底怎么改写，还没有想好。

我的代码

    public boolean isMatch(String s, String p) {
        if (p.isEmpty()) {
            return s.isEmpty();
        }
        boolean match = false;
        if (s.length() > 0) {
            if (s.charAt(0) == p.charAt(0) || p.charAt(0) == '.') {
                match = true;
            }
        }
        if (p.length() > 1 && p.charAt(1) == '*') {
            return (isMatch(s, p.substring(2))) || (match && isMatch(s.substring(1), p));
        } else {
            return match && isMatch(s.substring(1), p.substring(1));
        }
    }

非常令人难受的是，我细节写挂了好几次

最快代码

class Solution {
    public boolean isMatch(String s, String p) {
        boolean[] match = new boolean[s.length() + 1];
        match[s.length()] = true;

        for (int i = p.length() - 1; i >= 0; i --) {
            if (p.charAt(i) == '*') {
                for (int j = s.length() - 1; j >= 0; j --) {
                    match[j] = match[j] || (match[j + 1] && (p.charAt(i - 1) == '.' || p.charAt(i - 1) == s.charAt(j)));
                }
                i --;
            }

            else {
                for (int j = 0; j < s.length(); j ++) {
                    match[j] = match[j + 1] && (p.charAt(i) == '.'  || p.charAt(i) == s.charAt(j));
                }
                match[s.length()] = false;
            }
        }

        return match[0];
    }
}

应该就是我说的dp写法了，还是要学习一个。