44. Wildcard Matching (String; DP, Back-Track)

Implement wildcard pattern matching with support for '?' and '*'.

'?' Matches any single character.
'*' Matches any sequence of characters (including the empty sequence).不同于正则表达式中的*

*正则表达式的定义：

• '.' Matches any single character.

• '*' Matches zero or more of the preceding element.

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

The function prototype should be:
bool isMatch(const char *s, const char *p)

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

思路I：当遇到*，有把*跳过，和继续保留*两种option=>带回溯的递归。其实也可称之为贪心法，贪心法则是每次都使*匹配尽可能少的字符。

class Solution {
public:
    bool isMatch(string s, string p) {
        return backTracking(s,p,,);
    }

    bool backTracking(string s, string p, int sp, int pp){
        //end condition
        if(sp==s.length()){
            while(pp<p.length() &&p[pp]=='*' ){
                pp++;
            }
            if(pp == p.length()) return true;
            else return false;
        }
        if(pp==p.length()) return false;

        if(p[pp]=='*'){
            while(pp+<p.length() && p[pp+]=='*') pp++; //ignore the stars directly behind star
            if(backTracking(s,p,sp,pp+)) return true; //* not repeats
            return backTracking(s,p,sp+,pp); //* repeats
        }
        else if(s[sp]==p[pp] || p[pp]=='?') return backTracking(s,p,sp+,pp+);
        else return false;
    }
};

时间复杂度：二叉recursion的高度是2ⁿ  所以O(2ⁿ)

Result: Time Limit Exceeded

思路II：依然是带回溯的递归，只是记录下*号位置，和匹配的字符数，那么等到某次*不匹配时可直接回到该位置。

class Solution {
public:
    bool isMatch(string s, string p) {
        star = false;
        return recursiveCheck(s,p,,);
    }

    bool recursiveCheck(const string &s, const string &p, int sIndex, int pIndex){
        if(sIndex >= s.length()){
            while(p[pIndex] == '*' && pIndex < p.length()) pIndex++; //s has went to end, check if the rest of p are all *
            return (pIndex==p.length());
        }

        if(pIndex >= p.length()){
            return checkStar(s,p);
        }

        switch(p[pIndex]) //p: pattern，在p中才可能出现?, *
        {
        case '?':
            return recursiveCheck(s, p, sIndex+, pIndex+);
            break;
        case '*': //如果当前为*， 那么可认为之前的字符都匹配上了，并且将p移动到 * 结束后的第一个字符
            star = true;  //p 每次指向的位置，要么是最开始，要么是 * 结束的第一个位置
            starIndex = pIndex;
            matchedIndex = sIndex-;
            while(p[pIndex] == '*'&& pIndex < p.length()){pIndex++;} //忽略紧接在 *后面的*
            if(pIndex==p.length()) return true;//最后一位是*
            return recursiveCheck(s,p,sIndex,pIndex); //*匹配0个字符
            break;
        default:
            if(s[sIndex] != p[pIndex]) return checkStar(s, p);
            else return recursiveCheck(s, p, sIndex+, pIndex+);
            break;
         }
    }

    bool checkStar(const string &s, const string &p){
        if(!star) return false;
        else {
            int pIndex = starIndex+;
            int sIndex = ++matchedIndex; //回溯，*d多匹配一个字符
            return recursiveCheck(s, p, sIndex, pIndex);
        }
    }
private:
    int starIndex;
    int matchedIndex;
    bool star;
};

Result: Approved.

思路III:使用dp。dp[i][j]表示从字符串到i位置，模式串到j位置是否匹配。

class Solution {
public:
    bool isMatch(string s, string p) {
        int sLen = s.length();
        int pLen = p.length();
        if(sLen == ){
            int pp = ;
            while(pp<p.length() &&p[pp]=='*' ){
                pp++;
            }
            if(pp == p.length()) return true;
            else return false;
        }
        if(pLen == ) return false;

        int len = ;
        for(int i = ;i < pLen;i++)
            if(p[i] != '*') len++;
        if(len > sLen) return false; 

        bool dp[sLen][pLen];
        int i = , j = ;
        for(;i<sLen;i++){
            for(;j<pLen;j++){
                dp[i][j]=false;
            }
        }

        if(p[]=='*'){ //c;*?*
            for(i = ;i < sLen; i++ ){
                dp[i][] = true;
            }
        }

        //first line can appear one letter which is not star
        if (p[]=='?' || s[] == p[]){ //first not-star-letter appears
            dp[][] = true;
            for(j = ;(j < pLen && p[j]=='*'); j++ ){
                dp[][j]=true;
            }
        }
        else if(p[]=='*'){
            for(j = ;(j < pLen && p[j-]=='*'); j++ ){
                if(p[j]=='?' || s[] == p[j]){ //first not-star-letter appears
                    dp[][j]=true;
                    j++;
                    for(;j<pLen && p[j]=='*'; j++){ //after first not star, there should be all star
                        dp[][j]=true;
                    }
                    break;
                }
                else if(p[j]=='*'){
                    dp[][j]=true;
                }
            }
        }

        for(i = ; i < sLen; i++){
            for(j = ; j < pLen; j++){
                if(p[j]=='*'){
                    dp[i][j] = dp[i-][j] //* repeat 1 time
                    || dp[i][j-]; //*repeat 0 times
                }
                else if(s[i]==p[j] || p[j]=='?'){
                    dp[i][j] = dp[i-][j-];
                }
            }
        }

        return dp[sLen-][pLen-];
    }
};

时间复杂度：O(n2)

思路IV: 思路III的初始状态求法太复杂=>Solution：定义一个fake head。dp[0][0]表示两个空字符串的匹配情况，dp[0][0]=true.

class Solution {
public:
    bool isMatch(string s, string p) {
        int sLen = s.length();
        int pLen = p.length();
        if(sLen == ){
            int pp = ;
            while(pp<p.length() &&p[pp]=='*' ){
                pp++;
            }
            if(pp == p.length()) return true;
            else return false;
        }
        if(pLen == ) return false;

        vector<vector<bool>> dp(sLen+, vector<bool>(pLen+,));
        //initial states
        int i = , j = ;
        dp[][]=true;
        for(j = ;(j <= pLen && p[j-]=='*'); j++ ){
            dp[][j]=true;
        }

        //state transfer
        for(i = ; i <= sLen; i++){
            for(j = ; j <= pLen; j++){
                if(p[j-]=='*'){
                    dp[i][j] = dp[i-][j] //* repeat 1 time
                    || dp[i][j-]; //*repeat 0 times
                }
                else if(s[i-]==p[j-] || p[j-]=='?'){
                    dp[i][j] = dp[i-][j-];
                }
            }
        }

        return dp[sLen][pLen];
    }
};

思路V：节约空间，状态之和i-1有关，所以只要记录上一行状态就可以。可以用一维数组。

class Solution {
public:
    bool isMatch(string s, string p) {
        int sLen = s.length();
        int pLen = p.length();
        if(sLen == ){
            int pp = ;
            while(pp<p.length() &&p[pp]=='*' ){
                pp++;
            }
            if(pp == p.length()) return true;
            else return false;
        }
        if(pLen == ) return false;

        vector<bool> lastDP(pLen+, );
        vector<bool> currentDP(pLen+, );
        vector<bool> tmp;
        //initial states
        int i = , j = ;
        lastDP[]=true;
        for(j = ;(j <= pLen && p[j-]=='*'); j++ ){
            lastDP[j]=true;
        }

        //state transfer
        for(i = ; i <= sLen; i++){
            currentDP[]=false;
            for(j = ; j <= pLen; j++){
                if(p[j-]=='*'){
                    currentDP[j] = lastDP[j] //* repeat 1 time
                    || currentDP[j-]; //*repeat 0 times
                }
                else if(s[i-]==p[j-] || p[j-]=='?'){
                    currentDP[j] = lastDP[j-];
                }
                else{
                    currentDP[j] = false;
                }
            }
            tmp = currentDP;
            currentDP = lastDP;
            lastDP = tmp;
        }

        return lastDP[pLen];
    }
};