lc_dp_10_regexMatch

 题目：dif

 给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

说明:
    s 可能为空，且只包含从 a-z 的小写字母。
    p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

示例 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 = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。

示例 5:
输入:
s = "mississippi"
p = "mis*is*p*."
输出: false

 

package leetCode.DP;

public class lc_dp_10_regexMatch {
     

    /*
 思路：
    1)回溯法，本题回溯法更好，但要掌握dp的思想
    2)dp,难，注意理解

     */
    public static void main(String[] args) {
        lc_dp_10_regexMatch m = new lc_dp_10_regexMatch();
        boolean res = m.isMatch_recursion("ab",
                ".*..");
        System.out.println(res);
    }

    /*
    回溯法：
        如果模式串中有*号，让*出现在第二个位置，即 p[1]=*（如果不在第二个位子，除去p前面已匹配的，
    使之在第二个位置，即让p=x*xxx）。
        当*出现在第二个位置，我们有两种处理方式。
        1）可以直接忽略模式串中这一部分，即匹配0个
        2）或者删除匹配串s的第一个字符，前提是s能够匹配模式串第一个字符，
           即 p[0]。如果两种操作中有任何一种使得剩下的字符串能匹配，匹配串和模式串就可以被匹配。
     */
    public boolean isMatch_recursion(String s, String p) {
        //注意条件是p为空，不是s为空，反过来是错误的，如果p到头，s没到头，不匹配；
        //要是s到头，p没到头，可能匹配（后面存在x*情况），可能不匹配，继续判断
        //String的isEmpty()是在对象分配内存时，判断字符的长度。和length()原理一样，对象为null时出错
        if (p.isEmpty())
            return s.isEmpty();

        boolean isFirstMatch = !s.isEmpty() && (s.charAt(0) == p.charAt(0) || p.charAt(0) == '.');
        //1.如果p第二个为*，即x*xxx则有两种处理方式
//      1）p除去x*,继续匹配,即匹配0个
//      2）s除去已经匹配的第一个数字，p不变，继续匹配（表示匹配1-n个，其中先2)再1)即是1个，
//         所以不用考虑s除去第1个、p除去前2个的情况）

//        2.如果p第二个不为*，则正常匹配，注意第一个必须匹配，后面p和s都除去第一个
        if (p.length() > 1 && p.charAt(1) == '*') {//注意p.length>1,否则越界
            return isMatch_recursion(s, p.substring(2))
                    || (isFirstMatch && isMatch_recursion(s.substring(1), p));
        } else {//如果p.length<2,说明p到头了；如果p的第二个不为*，则p、s减去匹配的第一个
            return isFirstMatch && isMatch_recursion(s.substring(1), p.substring(1));
        }

    }

    /*
    dp:

    原文：https://leetcode-cn.com/problems/regular-expression-matching/solution/dong-tai-gui-hua-zen-yao-cong-0kai-shi-si-kao-da-b/

状态：
    首先状态 dp 一定要能自己想出来。
    dp[i][j] 表示 s 的前 i个是否能被 p 的前 j个匹配
转移方程：
    怎么想转移方程？首先想的时候从已经求出了 dp[i-1][j-1] 入手，再加上已知 s[i]、p[j]，
要想的问题就是怎么去求 dp[i][j]。
    已知 dp[i-1][j-1] 意思就是前面子串都匹配上了（或者没有匹配上，就是已经确定了），
不知道新的一位的情况。那就分情况考虑，所以对于新的一位 p[j] s[i] 的值不同，要分情况讨论：
    1）考虑最简单的 p[j] == s[i] : dp[i][j] = dp[i-1][j-1]
然后从 p[j] 可能的情况来考虑，让 p[j]=各种能等于的东西。
    2）p[j] == "." : dp[i][j] = dp[i-1][j-1]
    3）p[j] ==" * ":
第一个难想出来的点：怎么区分 * 的两种讨论情况
    首先给了 *，明白 * 的含义是 匹配零个或多个前面的那一个元素，所以要考虑他前面的元素 p[j-1]。
跟着他前一个字符走，前一个能匹配上 s[i]，* 才能有用，前一个都不能匹配上 s[i]，* 也无能为力，
只能让前一个字符消失，也就是匹配 0次前一个字符。
所以按照 p[j-1] 和 s[i] 是否相等，我们分为两种情况：
    3.1 p[j-1] != s[i] : dp[i][j] = dp[i][j-2]
        这就是刚才说的那种前一个字符匹配不上的情况。
        比如(ab, abc * )。遇到 * 往前看两个，发现前面 s[i] 的 ab 对 p[j-2] 的 ab 能匹配，虽然后面是 c*，但是可以看做匹配 0次 c，相当于直接去掉 c *，所以也是 True。注意 (ab, abc**) 是 False。
    3.2 p[j-1] == s[i] or p[j-1] == "."
        * 前面那个字符，能匹配 s[i]，或者 * 前面那个字符是万能的“.”
        因为 . * 就相当于 . .，那就只要看前面可不可以匹配就行。
        比如 (##b , ###b *)，或者 ( ##b , ### . * ) 只看 ### 后面一定是能够匹配上的。
        所以要看 b 和 b * 前面那部分 ## 的地方匹不匹配。

    第二个难想出来的点：怎么判断前面是否匹配
    dp[i][j] = dp[i-1][j] // 多个字符匹配的情况，p的前j个匹配了s的i-1个字符，此时可以再匹配一个，即匹配多个
    or dp[i][j] = dp[i][j-1] // 单个字符匹配的情况，p的前j-1个匹配了s的i-1个字符，此时相当于把*去除，即匹配了一个
    or dp[i][j] = dp[i][j-2] // 没有匹配的情况，p的前j-2个匹配了s的i个字符，直接除去了x*，即0个x，即匹配0个

    看 ### 匹不匹配，不是直接只看 ### 匹不匹配，要综合后面的 b b* 来分析
    这三种情况是 or的关系，满足任意一种都可以匹配上，同时是最难以理解的地方：

    dp[i-1][j] 就是看 s 里 b 多不多， ### 和 ###b * 是否匹配，一旦匹配，s 后面再添个 b 也不影响，因为有 * 在，也就是 ###b 和 ###b *也会匹配。
    dp[i][j-1] 就是去掉 * 的那部分，###b 和 ###b 是否匹配，比如 qqb qqb
    dp[i][j-2] 就是去掉多余的 b *，p 本身之前的能否匹配，###b 和 ### 是否匹配，比如 qqb qqbb* 之前的 qqb qqb 就可以匹配，那多了的 b * 也无所谓，因为 b * 可以是匹配 000 次 b，相当于 b * 可以直接去掉了。
    三种满足一种就能匹配上。

    为什么没有 dp[i-1][j-2] 的情况？ 就是 ### 和 ### 是否匹配？因为这种情况已经是 dp[i][j-1] 的子问题。也就是 s[i]==p[j-1]，则 dp[i-1][j-2]=dp[i][j-1]。

    最后来个归纳：
        如果 p.charAt(j) == s.charAt(i) : dp[i][j] = dp[i-1][j-1]；
        如果 p.charAt(j) == '.' : dp[i][j] = dp[i-1][j-1]；
        如果 p.charAt(j) == '*'：
            如果 p.charAt(j-1) != s.charAt(i) :
                dp[i][j] = dp[i][j-2] //in this case, a* only counts as empty
            如果 p.charAt(i-1) == s.charAt(i) or p.charAt(i-1) == '.'：
                dp[i][j] = dp[i-1][j] //in this case, a* counts as multiple a
                or dp[i][j] = dp[i][j-1] // in this case, a* counts as single a
                or dp[i][j] = dp[i][j-2] // in this case, a* counts as empty

     */
    public boolean isMatch(String s, String p) {
        int m = s.length();
        int n = p.length();
//        dp[i][j] 表示 s 的前i个是否能被 p 的前j个匹配
        // 这里dp矩阵是要大一圈的，用来处理s或者p为空串的情况(坐标为0时)，
        // 矩阵的行标i对应s的i-1，矩阵的列标j对应p的j-1
        boolean[][] dp = new boolean[m + 1][n + 1];
        // s和p都是空串的时候自然true
        dp[0][0] = true;
        // 初始化首列,p为空时，任何非空的s都不匹配
        for (int i = 1; i <= m; i++) {
            dp[i][0] = false;
        }
        // 初始化首行，p的匹配关系初始化，a*a*a*a*a*这种能够匹配空串，其他的是都是false。
        // 奇数位不管什么字符都是false（默认就是false），偶数位为* 时则: dp[0][i] = dp[0][i - 2]
        for (int j = 1; j <= n; j++) {
            if (j == 1 || p.charAt(j - 1) != '*')
                dp[0][j] = false;
            else
                dp[0][j] = dp[0][j - 2];

        }

        /*
        s或p为空字符串，可以进一步简化成这样：更好

        //"" 和p的匹配关系初始化，a*a*a*a*a*这种能够匹配空串，其他的是都是false。
        //  奇数位不管什么字符都是false（默认就是false），偶数位为* 时则: dp[0][i] = dp[0][i - 2]
        for (int j = 2; j <= n; j+= 2) {
            if (p.charAt(j - 1) == '*') {
                dp[0][j] = dp[0][j - 2];
            }
        }

        */
        // 通过递推公式开始填充矩阵
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (p.charAt(j - 1) != '*') {//当前的匹配模式字符！= '*'
                    //能匹配上的两种情况，此时看前面的dp[i - 1][j - 1]是否匹配
                    dp[i][j] = (p.charAt(j - 1) == s.charAt(i - 1) || p.charAt(j - 1) == '.')
                            && dp[i - 1][j - 1];
                } else {//当前的匹配模式字符== '*'
                    //当前p和s字符可匹配，看前面的情况
                    if (p.charAt(j - 2) == s.charAt(i - 1) || p.charAt(j - 2) == '.') {
                        //三种情况只要有一种匹配就能匹配
                        dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
                        //注意条件，否则越界：本题不会越界,*一定是出现在第二个之后的位置，
                        // 否则没有意义，即j>=2
                        if (j > 1) dp[i][j] = dp[i][j] || dp[i][j - 2];
                    } else {//当前的匹配模式字符== '*'且当前p和s字符不匹配
                        dp[i][j] = dp[i][j - 2];
                    }

                }
            }
        }


        return dp[m][n];
    }

}