leetcode10 正则表达式匹配

正则表达式匹配

给你一个字符串 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
解释：".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。

提示：
1 <= s.length <= 20
1 <= p.length <= 30
s 只包含从 a-z 的小写字母。
p 只包含从 a-z 的小写字母，以及字符 . 和 *。
保证每次出现字符 * 时，前面都匹配到有效的字符

解题思路：

dp[i][j] 表示匹配串s的前i个字符和模式串p前j个字符是否匹配

dp[0][0]= true 表示 s空串和p空串由于模式串空串可以匹配匹配串空串设置值为true

要求dp[i][j] 是否匹配需要区分2种情况 p[j-1] 是否为 * 字符第j个字符的索引为j-1

1.如果 p[j-1] == '*'
这里也有2种情况
1.1 当前*和前一个字符的组合什么也没有匹配到这里就相当于直接把模式串的当前的组合匹配去掉
此时dp[i][j]=dp[i][j-2]
1.2 当前*和前一个字符的组合匹配到值了则说明匹配串当前*的前一个字符和当前匹配串的i个字符需要匹配
match(s,p,i,j-1)
如果dp[i][j]想要匹配成功这里有两种情况 p[j-2] 是a-z的字母的一个字符 p[j-2] 是 .
1.2.1 如果p[j-2] == '.'
则dp[i][j] = dp[i-1][j]
1.2.2 如果p[j-2] 是a-z的一个字符
则 dp[i][j] = dp[i-1][j-1]
2. p[j-1] != '*'
计算dp[i][j]是否匹配的话需要知道当前匹配串的第i个字符和模式串的第j个字符是否相等或者模式串的第j个字符为. 就是字符匹配操作 match(s,p,i,j)
dp[i][j]=dp[i-1][j-1]

两种情况都使用到了匹配函数下面列出匹配函数
// 注意在java种获取一个字符使用 s.charAt(i) 下面为了方便写成中括号
public boolen match(String s,String p,int i, int j){
if (i < 1 || j < 1) return false;
if (p[j - 1] == '.') return true;
return s[i - 1] == p[j - 1];
}

public static boolean isMatch(String s, String p) {
        int m = s.length();
        int n = p.length();
        //dp数组 dp[i][j]  表示s前i个字符和p前j个字符匹配的结果
        boolean[][] dp = new boolean[m + 1][n + 1];
        //dp[0][0] s空串和p空串匹配成功
        dp[0][0] = true;
        // dp[0][1] - dp[0][j] 要设置为false boolean数组默认初始值为false 因此不需要设置
        for (int i = 0; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (p.charAt(j - 1) == '*') {
                    // *表示 匹配零个或多个前面的那一个元素
                    // 如果匹配到字符* 则说明 *和前面字符的组合 可能匹配到 也可能什么也没匹配到
                    // 例如 s="" p="c*"，s="c" p="c*",s="ccc" p="c*"  前面几种情况都是匹配的
                    // 所以这里处理第1种情况 直接丢弃这个组合的两个字符
                    // 根据已知条件可以知道*不可能是模式串p的第一个字符 下面的公式数组下标不可能越界
                    dp[i][j] = dp[i][j - 2];
                    // 这里处理第2种情况 让p串往前移动1个字符 和 s串的第i个字符匹配
                    if (match(s, p, i, j - 1)) {
                        // 匹配成功 则s前i个字符和p前j个字符匹配的结果
                        // 为 s前i-1个字符和p前j-1个字符匹配的结果
                        // 或者 * 的前面是.  则 s前i-1个字符和p的前i个字符匹配
                        dp[i][j] |= dp[i - 1][j - 1];
                        dp[i][j] |= dp[i - 1][j];
                    }
                } else {
                    if (match(s, p, i, j)) {
                        dp[i][j] = dp[i - 1][j - 1];
                    }
                }
            }
        }
        return dp[m][n];
    }

    public static boolean match(String s, String p, int i, int j) {
        if (j < 1 || i < 1) return false;
        // 模式串p 为. 则一定匹配
        if (p.charAt(j - 1) == '.') {
            return true;
        }
        return s.charAt(i - 1) == p.charAt(j - 1);
    }