【剑指Offer】面试题19：正则表达式匹配

/**
 * 面试题19：正则表达式匹配
 * 请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，
 * 而'*'表示它前面的字符可以出现任意次（包含0次）。
 * 在本题中，匹配是指字符串的所有字符匹配整个模式。
 * 例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配。
 *
 * 输入："aaa","a*a"
 * 输出：true
 * @author
 * @create 2021-04-15 17:03
 */
public class Solution19 {
    public static void main(String[] args) {
        String str = "";
        String pattern = "*";
        boolean match = matchdp(str, pattern);
        System.out.println(match);
    }

    /**
     * 方法一：剑指Offer
     * @param str
     * @param pattern
     * @return
     */
    public static boolean match (String str, String pattern) {
        // write code here
        if (str == null || pattern == null) {
            return false;
        }
        char[] strArray = str.toCharArray();
        char[] strPattern = pattern.toCharArray();
        return matchCore(strArray,0,strPattern,0);
    }

    public static boolean matchCore(char[] strArray,int s, char[] strPattern, int p){
        //递归条件
        if (s == strArray.length && p == strPattern.length){
            return true;
        }
        if (s < strArray.length && p == strPattern.length){
            return false;
        }
        //判断--> p+1位置为*
        if (p+1 < strPattern.length && strPattern[p+1] == '*'){
            //第一个位置匹配
            if (s < strArray.length &&
                    (strPattern[p] == strArray[s] || (strPattern[p] == '.'))){
                return matchCore(strArray,s,strPattern,p+2) || //忽略*前面的字符，进入下一个模式
                        //字符串向后移动一个字符，进入下一个模式
                        matchCore(strArray,s + 1,strPattern,p + 2) ||
                        matchCore(strArray,s + 1,strPattern, p);//字符串向后移动一个字符，模式不变
            }
            //第一个位置不匹配
            else {
                return matchCore(strArray,s,strPattern,p+2);//忽略*前面的字符，进入下一个模式
            }
        }

        //判断-->第二个位置不是*
        //第一个位置匹配
        if (s < strArray.length && (strArray[s] == strPattern[p] ||strPattern[p] == '.')){
            return matchCore(strArray,s+1,strPattern,p+1);
        }
        return false;
    }

    /**
     *方法二：动态规划，dp[i][j] 表示模式串前j个是否与字符串前i个匹配
     * @param str
     * @param pattern
     * @return
     */
    public static boolean matchdp(String str, String pattern){
        //1.初始化
        int m=str.length();
        int n=pattern.length();
        //这里不需要判断，因为模式串第一位不可能是 ‘*’
        if (pattern.charAt(0) == '*'){
            return false;
        }
        //00 用于存放两个空字符串的结果 dp[i][j] 表示模式串前j个是否与字符串前i个匹配
        boolean[][] dp =new boolean[m+1][n+1];
        //只有字符串和模式串都为空的时候才匹配，当模式串为空，字符串不为空则返回false，即dp[m][0]为false
        dp[0][0]=true;
        for(int j=2;j<=n;j++){
            //模式与空字符串匹配的情况只能是“.*”("a*"、"b*c*")
            //这里是匹配空字符串，".*a*b*"都可以匹配空
            if(pattern.charAt(j-1)=='*'&&dp[0][j-2]){
                dp[0][j]=true;
            }
        }

        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                //当前位置不为*，正常匹配或者模式串为. 就为true
                if(str.charAt(i-1)==pattern.charAt(j-1)||pattern.charAt(j-1)=='.'){
                    dp[i][j]=dp[i-1][j-1];
                }else if(pattern.charAt(j-1)=='*'){
                    //当前位置为*时，有两种情况：
                    // ①忽略*前面的字符，即当做空串，如果前一个模式可以匹配，那么当前模式就可以匹配
                    //比如：aaab和a*c*b，a*c不能匹配a，a*c*时前一个模式a*可以匹配a，那么a*c*就可以匹配a
                    if(dp[i][j - 2]){
                        dp[i][j]=dp[i][j-2];
                    }else{
                        //②判断*前面的字符是否与当前字符串中的字符相等，或者当前字符串中的字符为.
                        char pre=pattern.charAt(j-2);//保存*前面的字符
                        if(pre==str.charAt(i-1)||pre=='.'){
                            //如果*前面的字符等于当前字符或者为.   
                            dp[i][j]=dp[i-1][j];
                        }
                    }
                }
            }
        }
        return dp[m][n];
    }
}