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).

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

算法一：就用暴力搜，如果搜到某一步发现匹配失败再回溯。时间复杂度有点高。不是最优算法。

class Solution {
public:
    bool isMatch(string s, string p) {
        if(p=="") return s=="";
        string q = "";
        //预处理
        vector<int> star;
        vector<pair<int,int>> starStrIndex;  //first代表上一个*替代的子串的起始位置,second为终止位置的后继
        
        for(int i=0;i<p.length();){
            q.push_back(p[i]);
            if(p[i]=='*') while(i<p.length() && p[i]=='*') ++i;
            else ++i;
        }
        
        int i=0,j=0;  
        
        while(i<s.length() && j<q.length()){
            
            if(q[j]=='*'){
                star.push_back(j++);  //用于回溯
                if(j==q.length()) return true;  //q最后一个是*,且*之前匹配成功
                starStrIndex.push_back(pair<int,int>(i,i));  //first==second表示*替代empty sequence
            }
            else{
                if(q[j]=='?' || q[j]==s[i]){ 
                    ++i; ++j; 
                    if(j==q.length() && i==s.length()) return true;
                    if(j!=q.length()) continue;
                }
                //q已经匹配完但s没有或者
                //不匹配当前字符，回溯到上一个*
                if(star.empty()) return false;
                pair<int,int> strIndex = starStrIndex.back();
                i = strIndex.second+1; 
                if(i == s.length()){ //已经尝试过所有的匹配仍不成功，回溯到上一个*
                    star.pop_back();
                    starStrIndex.pop_back();
                    if(star.empty()) return false;
                    strIndex = starStrIndex.back();
                    i = strIndex.second + 1;
                    
                } 
                
                j = star.back() + 1;
                starStrIndex[starStrIndex.size()-1].second = i;
            }
        }
        //可能存在s匹配完了，但q仍然没匹配完
        return (j==q.length() && i==s.length()) || (j==q.length()-1 && q[j]=='*');
            
    }
};

有没有更好的算法呢？有！其实算法跟上面一样，但是上面算法做了很多多余搜索。上面的搜索是将 * 从匹配空串到匹配到串尾仍然匹配不成功则回溯到上一个*的地方继续匹配。 其实没有必要，因此如果当前的 * 匹配某子串能使得当前*与下一个*之间的串能完全匹配，那么如果下一个*如果匹配任何串都失败，那么如果回溯到当前*，将当前*继续匹配更长的串，则必然也会失败。 可以用反证法证明。即如果能够将当前*匹配更长的串使得最终匹配成功，以如下例子示例：

p:    .......*ababa*........

s:   ......... ababa..........

已知p的第一个*匹配到s中a的前驱字符会使得第二个*后面的内容无法得到成功匹配。 假设现在第一个*匹配到s中第一个b能使得最终成功匹配，则p中两个*之间的串ababa会与s中的aba..匹配，则s中第二个*及其后面的内容必与s中ababa..后面的内容匹配，我们记此时第二个*匹配的串为t，既然如此，那我在此前第一个*匹配s中第一个a的前驱时，另第二个*匹配..t不就能成功匹配了吗？这就造成矛盾。

class Solution {
public:
    bool isMatch(string s, string p) {
       bool star = false;
       int n = s.length(), m = p.length();
       int i = 0, j = 0;
       int x,y;
       while(i<n && j<m){
           if(p[j]=='?' || p[j]==s[i]){ 
               i++; j++; 
               if(i<n && j==m){
                   if(!star) return false;
                   y++; i = y; j = x+1;
               }
           }
           else if(p[j]=='*'){
               star = true;
               while(j<m && p[++j]=='*');
               if(j==m) return true;  
               x = j-1;  //记录'*'的位置
               y = i-1;  //记录'*'匹配的子串的最后一个字符
           }
           else{
               if(!star) return false; 
               y++;
               i = y;   //i回到*匹配的下一位置
               j = x+1;  //j回到*的后继位置
           }
       }
       
       while(j<m && p[j]=='*') j++;
       return (i==n && j==m); 
    }
};