Leetcode | 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

递归的话会超时。

Method I

然后想用二维的DP。

借用了discussion上面的图。m[i+1][j+1]就是p[0...i]与s[0...j]的匹配结果。

1. 如果p[i] = '?' 或者 p[i] = s[j] (暗含p[i] != '*'的意思），那么m[i+1][j+1]就是等于它的对角线左上方的位置, m[i][j]。也就是都移动了一个字符。

2. 如果p[i] = '*'。从图里面就可以看出来，从(3)走到(4)，其实p[0...3]="a?c*"应该是能够匹配到s[0...j]，2<=j<6。也就是说，m[4][3...6]=true；

就是从上一行找到第一个为true的位置，那么从当前行中从该位置到最后都应该设为true。

bool isMatch(const char *s, const char *p) {
    if (p == '\0') return (s == '\0');
    int n1 = strlen(s);
    int n2 = strlen(p);
    
    vector<vector<bool> > m(n2 + 1, vector<bool>(n1 + 1, false));
    m[0][0] = true;
    
    for (int i = 0; i < n2; ++i) {
        if (p[i] == '*') {
            int j = 0;
            for (j = 0; j <= n1; ++j) {
                if (m[i][j]) break;
            }
            if (j > n1) return false;
            for (int k = j; k <= n1; ++k) {
                m[i + 1][k] = true;
            }
        } else {
            for (int j = 0; j < n1; ++j) {
                if (p[i] == '?' || s[j] == p[i]) {
                    m[i + 1][j + 1] = m[i][j];
                }
            }
        }
    }

    return m[n2][n1];
} 

二维DP会报MLE，但是阿牧遥 用了一个dp[500][500]倒是可以通过。。。

优化

因为其实每次都是更新一行，可以将两维dp改成一维的dp。将上面的代码对应转换就行，不过要注意的是，不满足条件更新值的，需要设成默认值false；

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        if (p == '\0') return (s == '\0');
        int n1 = strlen(s);
        int n2 = strlen(p);
        int chars = 0;
        for(int i=0; p[i] != '\0'; ++i) if(p[i] != '*' && n1<++chars) return false;
        
        vector<bool> m(n1 + 1, false);
        m[0] = true;
        
        for (int i = 0; i < n2; ++i) {
            if (p[i] == '*') {
                int j = 0;
                for (j = 0; j <= n1; ++j) {
                    if (m[j]) break;
                }
                for (; j <= n1; ++j) {
                    m[j] = true;
            }
            } else {
                for (int j = n1 - 1; j >= 0; --j) {
                    if (p[i] == '?' || s[j] == p[i]) {
                        m[j + 1] = m[j];
                    } else {
                        m[j + 1] = 0;
                    }
                }
                m[0] = false;
            }
        }
    
        return m[n1];
    }
};

注意第8行，如果没有这一句就会TLE。主要是计算p里面的非*的字符，如果这个数目都比s的长度大，那么肯定匹配不完。直接返回true。这是为了过一个大数据。

Method II

遇到*的时候是可能需要回溯的。但是回溯是不是一定要回到回溯前的位置呢。比如s="aacb",p="a*a*b"。结果应该是为true的。

第一次遇到p[1]='*'，从s[1]开始匹配，s[1]=p[2], 第二次遇到p[3] ='*'，s[2]!=p[4]，此路不通，要回溯，是不是要回溯到p[2]和s[2]呢，其实不用。

因为我们最后面撞见了p[3]='*'，证明s[0...1]和p[0...2]是匹配的，那么直接从p[4]和s[3]回溯就可以了。p[4]=s[3]，所以返回true。

因为遇到*都是先将*从区配空串开始的，所以当*把s都一直匹配到末尾有三种情况：

1. p后面还有，但是都是*，还是返回true；

2. p后面还有，但不全是*，返回false；

3. p后面没有，匹配刚刚好。

lass Solution {
public:
    bool isMatch(const char *s, const char *p) {
        if (p == '\0') return (s == '\0');
        
        const char *backP = NULL, *backS = NULL;
        
        while (*s) {
            if (*p == '*') {
                while (*p != '\0' && *p == '*') p++;
                if (*p == NULL) return true; 
                backS = s;
                backP = p;
            } else if (*s == *p || *p == '?') {
                s++; p++;
            } else if (backP) {
                s = ++backS;
                p = backP;
            } else {
                return false;
            }
        }
        
        while (*p) {
            if (*p != '*') return false;
            p++;
        }
        
        return true;
    }
};

这里第10行，是压缩了p连续*的情况。多个*相连其实相同于一个*。backP指向的*的下一个字符。backS就是从S当前的位置开始。

third time.

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        if (p == NULL || *p == '\0') return (s == NULL || *s == '\0');
        const char* lastS = NULL, *lastP = NULL;
        
        while (*s != '\0') {
            if (*p != '\0' && (*s == *p || *p == '?')) {
                s++, p++;
            } else if (*p == '*') {
                for (; *p != '\0' && *p == '*'; p++);
                lastP = p;
                lastS = s;
            } else if (lastP != NULL) {
                p = lastP;
                s = ++lastS;
            } else {
                break;
            }
        }
        
        for (; *p != '\0' && *p == '*'; p++);
        return *p == '\0' && *s == '\0';
    }
};