10. 正则表达式匹配

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

示例 1：

输入：s = “aa” p = “a”
输出：false
解释：“a” 无法匹配 “aa” 整个字符串。
示例 2:

输入：s = “aa” p = “a*”
输出：true
解释：因为 ‘*’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。
示例 3：

输入：s = “ab” p = “."
输出：true
解释：".” 表示可匹配零个或多个（’*’）任意字符（’.’）。
示例 4：

输入：s = “aab” p = “cab”
输出：true
解释：因为 ‘*’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。
示例 5：

输入：s = “mississippi” p = “misisp*.”
输出：false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/regular-expression-matching
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/*class Solution {
    public boolean isMatch(String s, String p) {
        int n = s.length();
        int m = p.length();
        boolean[][] dp = new boolean[n + 1][m + 1];
        //S和P都为空时，匹配
        dp[0][0] = true;
        //当S为空，P不空，要看P是否为 a*b*这种结构
        for(int j = 1; j <= m; ++j) {
            if(p.charAt(j - 1) == '*') {
                dp[0][j] = dp[0][j - 2];
            }
        }
        for(int i = 1; i <= n; ++i) {
            for(int j = 1; j <= m; ++j) {
                //当前字符串是*，可以将 字符+*全部忽略掉，取f[i][j-2]的值
                //或者看模式串P的上一个字符串是否能跟字符串S匹配
                //如果能匹配上，可以忽略掉模式串的 字符+*，也可以忽略掉字符串S中的当前字符
                //这里其实跟递归一样，也有两条转移路径
                if(p.charAt(j - 1) == '*') {
                    if(p.charAt(j - 2) == s.charAt(i - 1) || p.charAt(j - 2) == '.') {
                        dp[i][j] = dp[i - 1][j] || dp[i][j - 2];
                    }
                    else {
                        dp[i][j] = dp[i][j - 2];
                    }
                }
                //单个字符匹配的情况     
                else {
                    if(p.charAt(j - 1) == s.charAt(i - 1) || p.charAt(j - 1) == '.') {
                        dp[i][j] = dp[i - 1][j - 1];
                    }
                }
            }
        }
        return dp[n][m];
    }    
}*/
class Solution {
    public boolean isMatch(String s, String p) {
        int len_s = s.length(), len_p = p.length();
        int[][] memo = new int[len_s][len_p];

        return dfs(s.toCharArray(), p.toCharArray(), len_s - 1, len_p - 1, memo) == 1;
    }

    private int dfs(char[] s, char[] p, int i, int j, int[][] memo) {
        if (j < 0) {
            return i < 0 ? 1 : 2;
        }
        if (i < 0) {
            return p[j] == '*' ? dfs(s, p, i, j - 2, memo) : 2;
        }
        if (memo[i][j] != 0) {
            return memo[i][j];
        }

        if (s[i] == p[j] || p[j] == '.') {
            memo[i][j] = dfs(s, p, i - 1, j - 1, memo);
        } else if (p[j] == '*') {
            if (s[i] == p[j - 1] || p[j - 1] == '.') {
                int n1 = dfs(s, p, i - 1, j , memo);
                int n2 = dfs(s, p, i, j - 2, memo);
                memo[i][j] = (n1 == 1 || n2 == 1) ? 1 : 2;
            } else {
                memo[i][j] = dfs(s, p, i, j - 2, memo);
            }
        }
        
        return memo[i][j];
    }
}