正则表达式匹配

一、需求

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

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

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

二、递归法

class Solution {
    public boolean isMatch(String s, String p) {
        return dp(s,0,p,0);
    }
    public static boolean dp(String s, int i, String p, int j) {
        int m = s.length();
        int n = p.length();
        // 模式串匹配结束，判断文本串还存不存在
        if(j == n) {
            return i == m;
        }
        // 文本串匹配结束，模式串要么匹配结束，要么剩余部分匹配零个字符
        if(i == m) {
            if(j == n) {
                return true;
            } else {
                return judgeSign(p, j, n);
            }
        }
        if(s.charAt(i) == p.charAt(j) || p.charAt(j) == '.') {
            if (j+1 < n && p.charAt(j+1) == '*') {
                // 匹配零次或多次
                return dp(s,i,p,j+2) || dp(s,i+1,p,j);
            } else {
                return dp(s,i+1,p,j+1);
            }
        } else {
            // 只能匹配零次
            if (j+1 < n && p.charAt(j+1) == '*') {
                return dp(s,i,p,j+2);
            } else {
                return false;
            }
        }
    }
    // 判断字符串的所有奇数个索引是否为'*'，比如a*b*
    public static boolean judgeSign(String p, int start, int end) {
        if((end - start) % 2 == 1) {
            return false;
        }
        for(int i = start + 1; i < end; i += 2) {
            if(p.charAt(i) != '*') {
                return false;
            }
        }
        return true;
    }
}

三、带有"备忘录"的递归法

package cn.pikaqiang;

import java.util.HashMap;
import java.util.Map;

public class Solution {

    public static void main(String[] args) {
        String s = "ab";
        String p = ".*c";
        boolean res = isMatch(s,p);
        System.out.println(res);
    }

    public static boolean isMatch(String s, String p) {
        Map<String, Boolean> memo = new HashMap<>();
        return dp(s,0,p,0, memo);
    }

    public static boolean dp(String s, int i, String p, int j, Map memo) {
        int m = s.length();
        int n = p.length();
        // 定义个变量方便存到map
        boolean res = false;
        // 模式串匹配结束，判断文本串还存不存在
        if(j == n) {
            return i == m;
        }
        // 文本串匹配结束，模式串要么匹配结束，要么剩余部分匹配零个字符
        if(i == m) {
            if(j == n) {
                return true;
            } else {
                return judgeSign(p, j, n);
            }
        }
        // 看看备忘录里有没有想要的
        if (memo.containsKey(i+","+j)) {
            return (boolean) memo.get(i+","+j);
        }
        if(s.charAt(i) == p.charAt(j) || p.charAt(j) == '.') {
            if (j+1 < n && p.charAt(j+1) == '*') {
                // 匹配零次或多次
                res = dp(s,i,p,j+2,memo) || dp(s,i+1,p,j,memo);
            } else {
                res = dp(s,i+1,p,j+1,memo);
            }
        } else {
            // 只能匹配零次
            if (j+1 < n && p.charAt(j+1) == '*') {
                res = dp(s,i,p,j+2,memo);
            } else {
                return false;
            }
        }
        memo.put(i+","+j,res);
        return res;
    }
    // 判断字符串的所有奇数个索引是否为'*'，比如a*b*
    public static boolean judgeSign(String p, int start, int end) {
        if((end - start) % 2 == 1) {
            return false;
        }
        for(int i = start + 1; i < end; i += 2) {
            if(p.charAt(i) != '*') {
                return false;
            }
        }
        return true;
    }
}