Leetcode OJ: 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).

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

是思路与正则匹配类似，个人感觉是比正则匹配那题要容易一些的，但一做才发现是个坑。

不过有了正则匹配那题当铺垫，还是能做出来的，LZ实在地把正则那题的思路搬过来（参考http://www.cnblogs.com/flowerkzj/p/3726667.html）

稍微改改就提交了，当然也是先用递归的方案。以下代码通不过：

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        if (*p == 0) return *s == 0;
        if (*p != '*') {
            return (*p == *s || (*p == '?' && *s != 0)) && isMatch(s+1, p+1);
        }
        while (*s != 0) {
            if (isMatch(s, p+1))
                return true;
            s++;
        }
        return isMatch(s, p+1);
    }
};

果断TLE，提示错误样例是

Last executed input:"aaabbbaabaaaaababaabaaabbabbbbbbbbaabababbabbbaaaaba", "a*******b"

看到那些*于是就合并呗，又是一个通不过的代码：

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        if (*p == 0) return *s == 0;
        if (*p != '*') {
            return (*p == *s || (*p == '?' && *s != 0)) && isMatch(s+1, p+1);
        }
        while (p[1] == '*')
            ++p;
        while (*s != 0) {
            if (isMatch(s, p+1))
                return true;
            ++s;
        }
        return isMatch(s, p+1);
    }
};

还是TLE，提示错误样例是老长的一段s与p，好吧，只能出大杀器，动态规划了！

还是稍稍改改正则匹配那题的动态规划的代码，但还是过不了，再贴一个过不了的代码：

class Solution {
public:
    bool isMatchSingle(char s, char p) {
        return (s == p || p == '?');
    }
    bool isMatch(const char *s, const char *p) {
        int slen = strlen(s);
        int plen = strlen(p);
        
        vector<int> dp1(slen + 1, false), dp2(slen + 1, false);
        vector<int> *pre = &dp1, *cur = &dp2;
        dp1[0] = true;
        
        while (*p != 0) {
            cur->assign(slen + 1, false);
            if (*p != '*') {
                for (int i = 0; i < slen; ++i) {
                    (*cur)[i + 1] = ((*pre)[i] && isMatchSingle(s[i], p[0]));
                }
            } else {
                (*cur)[0] = (*pre)[0];
                while (p[1] == '*')
                    ++p;
                for (int i = 0; i < slen; ++i) {
                    (*cur)[i + 1] = (*pre)[i + 1] || (*pre)[i] || (*cur)[i];
                }
            }
            ++p;
            swap(cur, pre);
        }
        return (*pre)[slen];
    }
};

还是TLE，提示错误样例是s是一个超长的a，p也是一个超长的a与*的结合。

这就让我要重新思考下了，通配符里没有像正则那样的a*这样的表达，要匹配多少个a就重复出现多少次！这样就造成p会特别长！

但我看这个样例的特点就是无限个重复，于是我就想到了是不是可以把p压缩一下，p的匹配单元不再是单个字符，按连续重复出现的子串为基本匹配单元。

比如说p = "*aaaabbb*"，则匹配单元为{"*", 4个"a", 3个"b", "*"}，为原来的9个匹配单元变成 了4个。于是按这思路把原来的改改，就有如下代码了。

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        int slen = strlen(s);
        int plen = strlen(p);
        
        // 记录当前字符及以后会连续出现多少次
        vector<int> scount(slen, 1);
        vector<int> pcount(plen, 1);
        
        for (int i = slen - 2; i >= 0; --i) {
            if (s[i] == s[i + 1])
                scount[i] = scount[i + 1] + 1;
        }
        
        for (int i = plen - 2; i >= 0; --i) {
            if (p[i] == p[i + 1])
                pcount[i] = pcount[i + 1] + 1;
        }
        
        
        vector<int> dp1(slen + 1, false), dp2(slen + 1, false);
        vector<int> *pre = &dp1, *cur = &dp2;
        dp1[0] = true;
        int pi = 0;
        while (p[pi] != 0) {
            cur->assign(slen + 1, false);
            if (p[pi] != '*') {
                // 这里更新的都是(*cur)[i + pcount[pi]]的值
                if (p[pi] != '?') { // 判断是否连续匹配pcount[pi]个p[pi]
                    for (int i = 0; i + pcount[pi] <= slen; ++i) {
                        (*cur)[i + pcount[pi]] = (*pre)[i] && p[pi] == s[i] && scount[i] >= pcount[pi];
                    } 
                } else { // 当是'?'时，只需要判断s还剩下足够的长度与匹配pcount[pi]的长度
                    for (int i = 0; i + pcount[pi] <= slen; ++i) {
                        (*cur)[i + pcount[pi]] = (*pre)[i] && s[i + pcount[pi] - 1] != 0;
                    }
                }
            } else {
                // 是'*'时就思路与正则的一致的
                (*cur)[0] = (*pre)[0];
                for (int i = 0; i < slen; ++i) {
                    (*cur)[i + 1] = (*pre)[i + 1] || (*pre)[i] || (*cur)[i];
                }
            }
            // 这里注意下一个pi是前进了pcount[pi]
            pi += pcount[pi];
            // 别忘了交换
            swap(cur, pre);
        }
        return (*pre)[slen];
    }
};

这段代码是290ms过的，感觉还有点慢，先说说这里的缺点吧

时间最坏的情况还是不可避免的O(mn)，空间复杂度为O(n)，m是p的长度，n是s的长度，每层都要遍历一次s。

1. 对于'*'其实在检查到上一层的第一个true后，以后的就一定是true，不需要再计算了。

2. 对于'?'或者是其它非'*'其实不需要遍历字符串，只需要遍历上一层为true的就可以了。

按以上缺点，引进了队列把上一层的true都记录下来，便于当前层的计算，提交了一记，268ms过了。没甚提升。

实在不太甘心，但又已经没思路了。于是。。

搜了下有没别的解法，然后就发现了小磊哥的http://fisherlei.blogspot.com/2013/01/leetcode-wildcard-matching.html（可能需要FQ）

代码写得很简短，我就format一下，然后贴过来吧，个人跑了下是120ms过的。

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        bool star = false;
        const char *str, *ptr;  
        for(str = s, ptr =p; *str!='\0'; str++, ptr++)  { 
            switch(*ptr) { 
                case '?':  break;  
                case '*': 
                    star =true; 
                    s=str, p =ptr; 
                    while(*p=='*') 
                        p++;  
                    if(*p == '\0') // 如果'*'之后，pat是空的，直接返回true    
                        return true;    
                    str = s-1;    
                    ptr = p-1;    
                    break;    
                default: {    
                    if(*str != *ptr) {    
                        // 如果前面没有'*'，则匹配不成功    
                        if(!star)    
                            return false;    
                        s++;    
                        str = s-1;    
                        ptr = p-1;    
                    }    
                }    
            }    
        }    
        while(*ptr== '*')    
            ptr++;    
        return (*ptr == '\0');    
    }
};

初看真没看太懂，debug一遍才知道了个究竟，其实思路是贪心。

这里先要看到这个通配符匹配与正则那道的最大区别，这里只有'*'是变长匹配的，其它都是单字符的匹配。于是在匹配的模板上其实只有两种

1. '*'：任意长度的匹配

2. '?'或任意非'*'字符：单字符匹配。

再联系本人动态规划的最终思路，用到了整块匹配的思路，但仅仅局限于连续出现的子串，是不是还可以拓展一下呢？

针对刚说过的通配符的分类方法，其实就可以把连续出现的单字符匹配模板作为一个整体匹配。

明白这个之后说说我对以上代码的理解吧。

这段代码中心思想是贪心，而匹配的单元分为两种

1. 连续的'*'子串，意义上其实是单个'*'

2. 连续的单字符匹配的子串

那怎么个贪心呢？

先看个例子吧：

s="aaabcaaabcaaabc", p="*bc*bc"

还是以动态规划的思路去分析吧，只是因为这符合贪心的思路，可以不需要整个DP都进行了。

p的匹配单元分别为{"*", "bc", "*", "bc\0"}（不要忘了最后的一个'\0'）

p[1]: "*"，按动态规划的数组，整行都会是true

p[2]:"bc"，按动态规划走过来，就会有三个地方是符合的

　　aaabcaaabcaaabc

好了，这里就开始考虑，能不能贪心了。

而在这里贪心的意思就是，我们匹配到了第一个"bc"时，是不是还需要再匹配下一个"bc"。

因为我们把p分成了'*'连续与非'*'连续的两种子串，那么"bc"的下一个子串若存在的话，一定就是"*"。

有这样的前提，我们来看看如果：

1. 第一个"bc"不是最优解时，最优解是第二或者第三个，"*"能匹配上

2. 第一个"bc"是最优解时，那没问题，我们可以继续匹配下一个了

Good Job. 这样就可以直接用贪心了！

于是到这里就只匹配第一个，往后p也只匹配后面的部分。

     aaabcaaabcaaabc

p[3]:"*"，都能匹配上，先放着

p[4]:"bc\0"，只有一个匹配

     aaabcaaabcaaabc

此时，p到结尾，s到结尾了，成功！

在这过程中，其实只要一段出现不匹配的情况，就可以直接返回false了。

perfect！

小磊哥写得很漂亮，不需要每次都遍历s，子串匹配时，只需要遍历部分，而空间复杂度是O(1)。