Leetcode做题记录——通配符匹配

44. 通配符匹配

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

'?' 可以匹配任何单个字符。
'*' 可以匹配任意字符串（包括空字符串）。

两个字符串完全匹配才算匹配成功。

说明:

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

示例 1:

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

示例 2:

输入:
s = "aa"
p = "*"
输出: true
解释: '*' 可以匹配任意字符串。

示例 3:

输入:
s = "cb"
p = "?a"
输出: false
解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。

示例 4:

输入:
s = "adceb"
p = "*a*b"
输出: true
解释: 第一个 '*' 可以匹配空字符串, 第二个 '*' 可以匹配字符串 "dce".

这题是难题，难在思路，开始我是当作模拟题来做，写一个match方法，该方法先匹配掉两边的字母，再匹配掉两边的？，最后两边都是*的情况下，去掉连续的重复*之后，两层for循环暴力枚举两边的*的匹配情况，每次枚举后调用match()方法递归，最后提交超时了。

看了题解，方法一是动态规划，dp[i][j]表示s的前i个字符和p的前j个字符能否匹配，这个我没有想到这题能用动态规划来做。

这里说的是方法二，贪心算法：

假如模式 p 的形式为 *u1*u2*u3*u4*….*ux*，即字符串(连续包含字母和？)和星号交替出现，并且首尾字符均为星号，那么我们就可以设计出下面这个基于贪心的暴力匹配算法。算法的本质是：如果在字符串 s中首先找到 u1，再找到u2、u3……，ux， 那么s就可以被p匹配。如果 ss 中多次出现了某个子串，那么我们选择最早出现的位置，可以使得后续子串能被找到的机会更大。

上面这个思路理解了就很简单了，剩下的就是模拟实现，先把连续出现的*合并为1个*，以*分割得到若干字符串数组，对每个字符串进行遍历匹配，匹配到后返回结尾下标作为下一个字符串开始匹配的下标。

    public boolean isMatch(String s, String p) {
        if (p.length() == 0) {
            return s.length() == 0;
        }
        p = removeDuplicate(p);
        if (!p.contains("*")) {
            int index = match(p, s, 0, true);
            return index != -1 && index == s.length() - 1; //注意这里的细节；
        }
        boolean shouldSearchFromStart = p.charAt(0) != '*';
        boolean shouldSearchFromEnd = p.charAt(p.length() - 1) != '*';
        String[] array = p.split("\\*");
        if (array.length == 0) {
            return true;
        }
        int start = 0;
        for (int i = 0; i < array.length; ++i) {
            if (shouldSearchFromEnd && (i == array.length - 1)) {
                break;
            }
            String sub = array[i];
            if (sub.length() == 0) {
                continue;
            }
            int index = match(sub, s, start, shouldSearchFromStart && (i == 0));
            if (index == -1) {
                return false;
            }
            start = index + 1;
        }
        if (shouldSearchFromEnd) {
            String sub = array[array.length - 1];
            if (start + sub.length() > s.length()) { //这里是一个细节，start后面不够字符串来匹配，即之前已经被匹配完了;
                return false;
            }
            int index = match(sub, s, s.length() - sub.length(), true);
            if (index == -1) {
                return false;
            }
        }
        return true;
    }

    //移除连续的 *;
    private String removeDuplicate(String p) {
        if (p.isEmpty()) {
            return p;
        }
        StringBuilder sb = new StringBuilder();
        sb.append(p.charAt(0));
        for (int i = 1; i < p.length(); ++i) {
            char c = p.charAt(i);
            if (c == '*' && c == p.charAt(i - 1)) {
                continue;
            }
            sb.append(c);
        }
        return sb.toString();
    }

    //p在s中进行匹配，从start开始，如果匹配上了，返回匹配上的子串末尾下标，否则返回-1;
    //matchOnce: 是否只匹配一次;
    private int match(String p, String s, int start, boolean matchOnce) {
        int pLength = p.length();
        for (int index = start; index < s.length(); ++index) {
            for (int i = index, j = 0; i < s.length() && j < pLength; ++i, ++j) {
                if (p.charAt(j) == '?') {
                    if (j == pLength - 1) {
                        return i;
                    }
                    continue;
                }
                if (p.charAt(j) != s.charAt(i)) {
                    break;
                }
                if (j == pLength - 1) {
                    return i;
                }
            }
            if (matchOnce) {
                return -1;
            }
        }
        return -1;
    }