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 +  != NULL && *(p+) == *p && *p == '*') p++;
         if (*p == '\0')
             return *s == '\0';
         if (*s == *p || *p == '?' && *s != '\0')
             return isMatch(s + , p + );
         else if (*p == '*')
         {
             if (*s == '\0')
                 return isMatch(s, p + );
             while(*s != '\0')
             {
                 if(isMatch(s, p + )) 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 = ;
        while (*tmp != '\0') if (*(tmp++) != '*') cnt++;
        if (cnt > len_s) return false;// 如果没有*的长度比待匹配的字符串还长是不可能匹配的，所以false  

        bool dp[len_s + ][len_p + ];
        memset(dp, false,sizeof(dp));  

        dp[][] = true;
        for (int i = ; i <= len_p; i++) {
            if (dp[][i-] && p[i-] == '*') dp[][i] = true; // p[i-1]是p的第i个，dp[][i-1]是到p的第i-1个
                                                        //所以如果p的前i-1个是*,并且第i个也是*的话，那么dp[0][i]就是真
            for (int j = ; j <= len_s; ++j)
            {
                if (p[i-] == '*') dp[j][i] = (dp[j-][i] || dp[j][i-]); //注意下标就发现，对应上面博文中的注释------a
                else if (p[i-] == '?' || p[i-] == s[j-]) dp[j][i] = dp[j-][i-];  //对应博文中的------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难。。。