Wildcard Matching

一. Wildcard Matching

Implement wildcard pattern matching with support for ‘?’ and ‘*’.

‘?’ Matches any single character.
‘*’ Matches any sequence of characters (including the empty sequence).

The matching should cover the entire input string (not partial).

Some examples:

isMatch(“aa”,”a”) → false
isMatch(“aa”,”aa”) → true
isMatch(“aaa”,”aa”) → false
isMatch(“aa”, “*”) → true
isMatch(“aa”, “a*”) → true
isMatch(“ab”, “?*”) → true
isMatch(“aab”, “c*a*b”) → false

Difficulty:Hard

TIME：20MIN

解法一（动态规划）

之前做过一道十分相似的题Regular Expression Matching，这道题和正则表达式十分相似，

• 这道题的 * 相当于正则表达式的 .*
• 这道题的 ? 相当于正则表达式的 .

因此这道题完全可以套用正则表达式动态规划解法，而且处理的情况会更加少，思路也会更加简单。

bool isMatch(string s, string p) {
    vector<vector<bool>> v(s.size() + 1,vector<bool>(p.size() + 1,false));
    v[0][0] = true;
    //初始化长度为0的情况
    for(int i = 1; i <= p.size(); i++) {
        if(p[i - 1] == '*' && v[0][i - 1])
            v[0][i] = true;
    }

    for(int i = 1; i <= s.size(); i++) {
        for(int j = 1; j <= p.size(); j++) {
            //如果匹配到*
            if(p[j - 1] == '*') {
                //可以选择跳过或者匹配一次
                if(v[i][j - 1] || v[i - 1][j])
                    v[i][j] = true;
            }
            else if(p[j - 1] == s[i - 1] || p[j - 1] == '?') {
                v[i][j] = v[i - 1][j - 1];
            }
        }
    }
    return v[s.size()][p.size()];
}

代码的时间复杂度为$O(n^2)$。

解法二（贪心算法）

这道题既然考虑的情况比正则表达式匹配要少，那么是否可以用贪心算法来解呢？

这道题贪心的思路在于，如果遇到 * 号，则优先跳过，然后记录这个星号出现的位置，继续匹配后面的字符，如果后面某个字符不能匹配，则回溯到上一个星号的位置，这个时候匹配一个字符。

比如字符串s为aab，字符串p为*ab，那么匹配过程如下：

• 首先跳过星号，发现s[0] = p[1]，然后两个字符串的位置后移一位
• 然后发现s[1] != p[2]，说明匹配失败，这个时候回溯到上一个星号的位置，*匹配一个字符，也就是s[0]
• 接着继续跳过星号，发现s[1]=p[1]，接着s[2]=p[2]，然后匹配完成。

至于为什么一定是回溯到上一个星号，而不是上上个星号。可以证明，回溯到上一个星号如果能够匹配，那么回溯到上上个星号也能够匹配。反之亦然。

bool isMatch(string s, string p) {
    int i = 0, j = 0;
    int posI = 0, posJ = -1;
    while(i < s.size()) {
        //如果恰好匹配，那么记录前移
        if(j < p.size() && (s[i] == p[j] || p[j] == '?')) {
            i++;
            j++;
        }
        //如果发现星号，则记录该星号的位置，方便以后回溯
        else if(j < p.size() && p[j] == '*') {
            posI = i;
            posJ = j;
            j++;
        }
        //如果不能匹配，则回溯到上一个星号，匹配一个字符
        else if(posJ != -1) {
            j = posJ;
            i = posI + 1;
        }
        else
            return false;
    }
    //查看模式字符串剩余的是否全是*，否则匹配不成功
    while(j < p.size() && p[j] == '*')
        j++;
    return j == p.size();
}

代码的时间复杂度介于$O(n)$和$O(n^2)$之间。