今日打脸：正则表达式匹配

心情

一道困难题做了一天，还没做出来。看了答案，依然无法做出来。。。
在观摩大神中看到了几种方案，会陆续补充到此篇中。

读题

leetcode： 10. 正则表达式匹配

描述：
给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。
‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *

测试用例：
输入: s = “aa” p = “a” 输出: false
输入: s = “aa” p = “a*” 输出: true
输入: s = “ab” p = “.*” 输出: true
输入: s= “aab” p = “c*a*b” 输出: true
输入: s = “mississippi” p = “mis*is*p*.” 输出: false

试过了字符串匹配，无法解决*匹配的个数问题导致未能解出此题。

思路

递归回溯法
动态规划法
有限状态机

官方题解-动态规划法

public boolean isMatch(String s, String p) {
    int m = s.length();
    int n = p.length();
	 //f[i][j]:s 的前 i 个字符与 p 中的前 j 个字符是否能够匹配。
    boolean[][] f = new boolean[m + 1][n + 1];
    f[0][0] = true;
    for (int i = 0; i <= m; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (p.charAt(j - 1) == '*') {
                f[i][j] = f[i][j - 2];
                if (matches(s, p, i, j - 1)) {
                    f[i][j] = f[i][j] || f[i - 1][j];
                }
            } else {
                if (matches(s, p, i, j)) {
                    f[i][j] = f[i - 1][j - 1];
                }
            }
        }
    }
    return f[m][n];
}

public boolean matches(String s, String p, int i, int j) {
    if (i == 0) {
        return false;
    }
    if (p.charAt(j - 1) == '.') {
        return true;
    }
    return s.charAt(i - 1) == p.charAt(j - 1);
}

官方题解

递归回溯法

class Solution {
	//用来保存匹配过的模式，避免重复匹配
    private static HashMap<String,Boolean> cache = new HashMap<>();
    public  boolean isMatch(String s, String p) {
        String key = s+"|"+p;
        Boolean ans = cache.get(key);
        if(ans!=null){
            return ans;
        }
        //若是p以*打头，直接剔除此*
        if (p.startsWith("*")) return isMatch(s, p.substring(1));
        //边界条件，全部匹配完
        if (s.intern() == "" && p.intern() == "") return true;
        //判断当前字符是否匹配
        boolean firstMatch = s.length() > 0 && p.length() > 0 && (s.charAt(0) == p.charAt(0) || p.charAt(0) == '.');
        if (p.length() >= 2 && p.charAt(1) == '*') {
            //字符+*的组合,先匹配0个，再匹配1个。
            ans = isMatch(s, p.substring(2)) || (firstMatch && isMatch(s.substring(1), p));
            cache.put(key,ans);
            return ans;
        } else if (p.length() >= 1) {
            //单字符匹配，没有*的情况；
            ans = firstMatch && isMatch(s.substring(1), p.substring(1));
            cache.put(key,ans);
            return ans;
        }
        return false;
    }
}