LeetCode Wildcard Matching

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        if (s == NULL || p == NULL) return false;
        int slen = 0;
        int plen = 0;
        
        while (s[slen] != '\0') slen++;
        while (p[plen] != '\0') plen++;
        
        if (slen == 0 && plen == 0) return true;
        if (plen == 0) return false;
        
        int si = 0;
        int pi = 0;
        int ppi = -1;
        int psi = 0;
        
        while (si < slen) {
            if (s[si] == p[pi] || p[pi] == '?') {
                si++, pi++;
            } else if (p[pi] == '*') {
                ppi = pi++;
                psi = si;
            } else if (ppi != -1){
                pi = ppi + 1;
                si = ++psi;
            } else {
                return false;
            }
        }

        while (p[pi] == '*') pi++;
        return pi == plen;
    }
};

 真写不出这样的代码。

参考：http://www.cnblogs.com/zhuli19901106/p/3572736.html

 

下面是自己写的记忆搜索代码，TLE了

class Solution {
private:
    char* memo;
    int slen;
    int plen;
public:
    bool isMatch(const char *s, const char *p) {
        slen = strlen(s);
        plen = strlen(p);
        
        memo = new char [(slen+1) * (plen+1)];
        for (int i=(slen+1) * (plen+1) - 1; i>=0; i--) memo[i] = -1;
        bool ret = dfs(s, 0, p, 0);
        delete[] memo;
        return ret;
    }
    
    bool dfs(const char* s, int spos, const char* p, int ppos) {
        int idx = ppos * slen + spos;
        if (memo[idx] >= 0) return memo[idx];
        
        if (s[spos] == '\0' && p[ppos] == '\0') return true;
        if (p[ppos] == '\0') return false;
        if (s[spos] == '\0') {
            int i = ppos;
            for (; p[i] != '\0'; i++) {
                if (p[i] != '*') break;
            }
            memo[idx] = p[i] == '\0';
            return memo[idx];
        }
        
        
        bool ret = false;

        if (p[ppos] == '?') {
            ret = dfs(s, spos + 1, p, ppos + 1);
        } else if (p[ppos] == '*') {
            for (int i=0; s[spos + i] != '\0'; i++) {
                if (dfs(s, spos + i, p, ppos + 1)) {
                    ret = true;
                    break;
                }
            }
        } else if (p[ppos] == s[spos]) {
            ret = dfs(s, spos + 1, p, ppos + 1);
        }
        memo[idx] = ret;
        return ret;
    }
};

 

第二轮：

再理解一下，source字符串和pattern字符串，设有两个指针si, pi分别指向source和pattern，

1. 如果遇到普通字符和?则依次匹配，即si++, pi++，如果此时发生失配且前面没有*出现，则此时已经无可奈何，匹配失败

2. 如果遇到有*，则记录此时的si为psi，pi为ppi。如字符串：

    abcddde

    ab*d?

    前面的ab匹配完成时，在pattern中遇到*，*可以匹配任意长度的字符，即可以产生以下几种尝试：

    1. ab cddde <-----> ab d?   (忽略*，即*匹配零个字符，si = psi,       pi = ppi + 1)

    2. ab ddde <------> ab d?  (*代替一个c,                    si = psi + 1,  pi = ppi + 1)

    3. ab dde <-------> ab d? (*代替cd,                          si = psi + 2, pi = ppi + 1)

    4. ab de <--------> ab d? (*代替cdd,                        si = psi + 3,  pi = ppi + 1)

    ...

由于我们记录了发现*时的索引，当我们在后续的尝试中失败时可以换另一种进行尝试。比如上述列表中1尝试失败时，可以立即尝试2中的情况，如此继续下去。 

又默写了一遍，算题真是无奈。

有写了一次还是不流畅，函数签名换了

class Solution {
public:
    bool isMatch(string s, string p) {
        int slen = s.size();
        int plen = p.size();
        s = s+"_";
        p = p+"_";
        int si = 0;
        int pi = 0;
        int wpi = -1;
        int wsi = -1;
        
        while (si < slen) {
            if (s[si] == p[pi] || p[pi] == '?') {
                si++, pi++;
            } else if (p[pi] == '*') {
                wsi = si;
                wpi = pi++;
            } else if (wpi != -1) {
                si = ++wsi;
                pi = wpi + 1;
            } else {
                return false;
            }
        }
        
        while (pi < plen) {
            if (p[pi++] != '*') {
                return false;
            }
        }
        
        return true;
    }
};

 再来，凡人只能勤加练习

// 10:15
// abcdef$
// ab$
class Solution {
public:
    bool isMatch(string s, string p) {
        
        int slen = s.size();
        int plen = p.size();
        
        s.push_back('$');
        p.push_back('$');
        
        int si = 0;
        int pi = 0;
        
        int psi = -1;
        int ppi = -1;
        
        while (si < slen) {
            if (s[si] == p[pi] || p[pi] == '?') {
                si++, pi++;
            } else if (p[pi] == '*') {
                psi = si;
                ppi = ++pi;
            } else if (psi != -1) {
                si = ++psi;
                pi = ppi;
            } else {
                return false;
            }
        }
        
        while (pi < plen) {
            if (p[pi++] != '*') {
                return false;
            }
        }
        return true;
    }
};

这里向末尾加入截止符可以避免一些边界上的处理，但必须是字符串中不会出现的，在C里面可以选择使用'\0'，其实C++里也可以push_back进去，不过这样太奇葩。