Leetcode 44. 通配符匹配

题目

给定一个字符串 (s) 和一个字符模式 ( p ) ，实现一个支持 ‘?’ 和 ‘*’ 的通配符匹配。

‘?’ 可以匹配任何单个字符。
‘*’ 可以匹配任意字符串（包括空字符串）。
两个字符串完全匹配才算匹配成功。

说明:

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

示例 1:

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

…

示例 5:

输入:
s = “acdcb”
p = “a*c?b”
输入: false

解答

解法一：递归

每个 * 号有用与不用两种选择。

1. 若 p 的第一个字符是 * ：
   1. 用 * ，相当于 !s.isEmpty() && isMatch(s.substring(1), p) 。
   2. 不用 * ，相当于 isMatch(s, p.substring(1)) 。
2. 若 p 的第一个字符不是 * ：判断第一个字符是否匹配，以及二者后续字符是否匹配。

结果超时了，分析了一下，发现有大量重复的递归分支。可以通过备忘录来改善这个问题 。

代码

class Solution {
    public boolean isMatch(String s, String p) {
        if(p.isEmpty()) return s.isEmpty();
        
        boolean firstMatch = !s.isEmpty() && (s.charAt(0) == p.charAt(0) || p.charAt(0) == '?');
        if(p.charAt(0) == '*') {
            return (!s.isEmpty() && isMatch(s.substring(1), p)) || isMatch(s, p.substring(1));
        } else {
            return firstMatch && isMatch(s.substring(1), p.substring(1));
        } 
    }
}

结果

备忘录代码

class Solution {

    Boolean[][] memo;
    public boolean isMatch(String s, String p) {
        memo = new Boolean[s.length() + 1][p.length() + 1];
        return isMatch(s.toCharArray(), 0, p.toCharArray(), 0);
    }
    
    private boolean isMatch(char[] ss, int i, char[] ps, int j) {
        if(memo[i][j] != null) return memo[i][j];
        
        boolean result = false;
        if(j == ps.length) {
            result = i == ss.length;
        } else {
            boolean firstMatch = i != ss.length && (ss[i] == ps[j] || ps[j] == '?');
            if(ps[j] == '*') {
                result = (i != ss.length && isMatch(ss, i + 1, ps, j)) || isMatch(ss, i, ps, j + 1);
            } else {
                result = firstMatch && isMatch(ss, i + 1, ps, j + 1);
            } 
        }
        
        memo[i][j] = result;
        return result;
    }
}

结果

解法二：动态规划

将上述递归改成自底向上的动态规划即可，思想是一样的。

本处的动态规划相当于上述解法一 递归 + 备忘录 的效果。

代码

class Solution {
    public boolean isMatch(String s, String p) {
        if(p.isEmpty()) return s.isEmpty();
        
        boolean[][] dp = new boolean[s.length() + 1][p.length() + 1];
        dp[s.length()][p.length()] = true;        
        for(int i = s.length(); i >= 0; i --) {
            for(int j = p.length() - 1; j >= 0; j --) {
                boolean firstMatch = i < s.length() && (s.charAt(i) == p.charAt(j) || p.charAt(j) == '?');
                if(p.charAt(j) == '*') {
                    dp[i][j] = (i < s.length() && dp[i + 1][j]) || dp[i][j + 1];
                } else {
                    dp[i][j] = firstMatch && dp[i + 1][j + 1];
                }
            }
        }
        
        return dp[0][0];
    }
}

结果