**leetcode 44 Wildcard Matching

没做出来
Time Limit Exceeded

class Solution {
public:

    typedef string::iterator SIt;

    bool isMatch(string s, string p) {

        send = s.end();
        pend = p.end();
        return isMatchRecursion(s.begin(), p.begin());
    }

private:
    bool isMatchRecursion(SIt sb, SIt pb) {
        SIt sit = sb;
        SIt pit = pb;

        while (sit != send && pit != pend) {

            if (*sit == *pit || *pit =='?') {
                ++sit;
                ++pit;
                continue;
            } 

            break;
        }

        if (pit == pend && sit == send) return true;
        if (pit == pend && sit != send) return false;
        if (sit == send && *pit != '*')  return false;

        // sit == send OR sit != send
        if (*pit == '*') {
            ++pit;
            for (SIt it = sit; it <= send; ++it) {
                if (isMatchRecursion(it, pit)) return true;       
            }
            return false;
        }

        // sit != send && pit != '*';
        return false; // *sit != *pit

    }

    SIt pend;
    SIt send;
};

参考后
1. 迭代

class Solution {
public:
    typedef string::iterator SIt;
    typedef string::size_type sz;

    bool isMatch(string s, string p) {
        sz i = 0; // id of s
        sz j = 0;

        sz ss = 0; // 标记与p中‘*’对应的点
        sz pp = 0; // 标记'*'处
        sz sSize = s.size();
        sz pSize = p.size();

        while ((i != sSize) && (i != pSize) && (s[i] == p[i] || p[i] == '?')) {
            ++i;
        }

        if (i == pSize) {
            if (i == sSize) return true;
            if (i != sSize) return false;

        } 

        // s 到头, 
        // p 与 s 不相等
        // 以上两种情况中只有p[i] == '*' 时才有可能返回true
        if (p[i] == '*') {

            j = i;
            ss = i;

            pp = j; // the id of the position of astroid
            j = pp + 1;

            if (j == pSize) return true;

            while (i != sSize) {
                if (p[j] == s[i] || p[j] == '?') {
                    ++i;
                    ++j;
                } else if (p[j] == '*') {
                    ss = i;
                    pp = j;
                    j = pp + 1;
                    if (j == pSize) return true;
                } else {
                    i = ++ss;
                    j = pp + 1;  // 重新找
                }       
            }

            // 如果p剩下的都是'*' 或都是没有了返回true
            while (j != pSize) {
                if (p[j] != '*') {
                    return false;
                }
                ++j;
            }
            return true;
        }

        // 其余的返回 false;
        return false; 
    }
};

2，动态规划

class Solution {
public:
    typedef string::size_type sz;

    bool isMatch(string s, string p) {

        // dynamic programming

        const sz sSize = s.size();
        const sz pSize = p.size();

        vector<int> cols(pSize + 1, false); 
        vector<vector<int> >  tab(sSize + 1, cols);

        tab[0][0] = true;

        for (sz j = 0; j != pSize; ++j) {
            if (tab[0][j] == true && p[j] == '*')
                tab[0][j + 1] = true;
        }

        for (sz j = 0; j != pSize; ++j) {
            if (p[j] == '*') {
                for (sz i = 0; i <= sSize; ++i) {
                     if (tab[i][j] == true) {
                        for (sz k = i; k <= sSize; ++k) {
                            tab[k] [j + 1] = true;
                        }
                        break;
                    } 
                }

            } else {
                for (sz i = 0; i != sSize; ++i) {
                    if (tab[i][j] == true && (p[j] == s[i] || p[j] == '?')) {
                        tab[i + 1][j + 1] = true;
                    }
                }
            }
        } 
        return tab[sSize][pSize];
    }
};

/* 这个循环方式更高效
        for (sz j = 1; j <= pSize; ++j) {
            for (sz i = 1; i <= sSize; ++i) {
                if (p[j - 1] == '*') {
                    tab[i][j] = tab[i][j - 1] || tab[i - 1][j];
                } else {
                    if (tab[i - 1][j - 1] == true && (p[j - 1] == s[i - 1] || p[j - 1] == '?')) {
                        tab[i][j] = true;
                    }
                }
            }
        }
*/