leetcode 第43题 Wildcard Matching

题目：（这题好难。题目意思类似于第十题，只是这里的*就是可以匹配任意长度串，也就是第十题的‘.*’）
'?' 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(const char *s, const char *p)
    {
        while(p + 1 != NULL && *(p+1) == *p && *p == '*') p++;
        if (*p == '\0')
            return *s == '\0';
        if (*s == *p || *p == '?' && *s != '\0')
            return isMatch(s + 1, p + 1);
        else if (*p == '*')
        {
            if (*s == '\0')
                return isMatch(s, p + 1);
            while(*s != '\0')
            {
                if(isMatch(s, p + 1)) return true;
                s++;
            }
        }
        return false;
    }
};

其实这个动态规划也不那么好理解。看了半天才把这个人的代码看懂。我加了注释如下:

主要就是要弄清楚下标。他的下标有点乱，但又不得不那样。dp[lens + 1][lenp + 1]是因为还要存长度为0 和0的匹配，以及0和若干个*的匹配都是真值。

dp[j][i]的意思是，s的第1到j和p的第1到i是否匹配，也就是下标s的0到j-1的字符串和p的下标0到i-1的字符串是否匹配。

则：

if p[j] == '*' && (dp[i][j-1] || dp[i-1][j])  ------a

dp[i][j] =  1 

else p[j] = ? || p[j] == s[i]     -------b

dp[i][j] = dp[i-1][j-1];

else dp[i][j] = false;     --------c

class Solution {  
public:  
  
    bool isMatch(const char *s, const char *p) {  
        int len_s = strlen(s);  
        int len_p = strlen(p);  
  
        const char* tmp = p;  
        int cnt = 0;  
        while (*tmp != '\0') if (*(tmp++) != '*') cnt++;  
        if (cnt > len_s) return false;// 如果没有*的长度比待匹配的字符串还长是不可能匹配的，所以false  
          
        bool dp[len_s + 1][len_p + 1];  
        memset(dp, false,sizeof(dp));  
  
        dp[0][0] = true;  
        for (int i = 1; i <= len_p; i++) {  
            if (dp[0][i-1] && p[i-1] == '*') dp[0][i] = true; // p[i-1]是p的第i个，dp[][i-1]是到p的第i-1个
                                                        //所以如果p的前i-1个是*,并且第i个也是*的话，那么dp[0][i]就是真        
            for (int j = 1; j <= len_s; ++j)  
            {  
                if (p[i-1] == '*') dp[j][i] = (dp[j-1][i] || dp[j][i-1]); //注意下标就发现，对应上面博文中的注释------a  
                else if (p[i-1] == '?' || p[i-1] == s[j-1]) dp[j][i] = dp[j-1][i-1];  //对应博文中的------b
                else dp[j][i] = false;  //对应博文中的-------c
            }  
        }  
        return dp[len_s][len_p];  
    }  
};

还有一个是据说80ms过的。用贪心的。贴出如下：

class Solution {  
public:  
bool isMatch(const char *s, const char *p) {  
    // Start typing your C/C++ solution below  
    // DO NOT write int main() function  
    if(!s && !p) return true;  
  
    const char *star_p=NULL,*star_s=NULL;  
  
    while(*s)  
    {  
        if(*p == '?' || *p == *s)  
        {  
            ++p,++s;  
        }else if(*p == '*')  
        {  
            //skip all continuous '*'  
            while(*p == '*') ++p;  
  
            if(!*p) return true; //if end with '*', its match.  
  
            star_p = p; //store '*' pos for string and pattern  
            star_s = s;  
        }else if((!*p || *p != *s)  && star_p)  
        {  
            s = ++star_s; //skip non-match char of string, regard it matched in '*'  
            p = star_p; //pattern backtrace to later char of '*'  
        }else  
            return false;  
    }  
  
    //check if later part of p are all '*'  
    while(*p)  
        if(*p++ != '*')  
            return false;  
  
    return true;  
}  
};  

最后我想说，真TM难。。。