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(n2) 。

解法二（貪心算法）

這道題既然考慮的情況比正則表達式匹配要少，那麼是否可以用貪心算法來解呢？

這道題貪心的思路在於，如果遇到 * 號，則優先跳過，然後記錄這個星號出現的位置，繼續匹配後面的字符，如果後面某個字符不能匹配，則回溯到上一個星號的位置，這個時候匹配一個字符。

比如字符串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(n2) 之間。