LeetCode44 Wildcard Matching 通配符匹配

问题描述：
Given an input string (s) and a pattern (p), 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).

Note:

s could be empty and contains only lowercase letters a-z.
p could be empty and contains only lowercase letters a-z, and characters like ? or *.
Example 1:

Input:
s = "aa"
p = "a"
Output: false

Explanation: “a” does not match the entire string “aa”.
Example 2:

Input:
s = "aa"
p = "*"
Output: true

Explanation: ‘*’ matches any sequence.
Example 3:

Input:
s = "cb"
p = "?a"
Output: false

Explanation: ‘?’ matches ‘c’, but the second letter is ‘a’, which does not match ‘b’.
Example 4:

Input:
s = "adceb"
p = "*a*b"
Output: true

Explanation: The first ‘’ matches the empty sequence, while the second ‘’ matches the substring “dce”.
Example 5:

Input:
s = "acdcb"
p = "a*c?b"
Output: false

题源：here；完整代码：here
思路：
两种方案：1 同第10题的解法类似，采用动态规划来完成； 2 利用类似迭代的巧妙方法。
方案1

    bool isMatch_1(string s, string p) {
        int sLen = s.size(), pLen = p.size();
        if (sLen == 0 && pLen == 0) return true;
        vector<vector<bool>> dp(sLen+1, vector<bool>(pLen + 1, false));
        dp[sLen][pLen] = true;
        int i = sLen - 1, j = pLen - 1;
        for (int i = sLen; i >= 0;i--){
            for (int j = pLen - 1; j >= 0; j--){
                if (p[j] == '?') dp[i][j] = i + 1 <= sLen && dp[i + 1][j + 1];
                else if (p[j] == '*') dp[i][j] = dp[i][j + 1] || (i + 1 <= sLen && dp[i + 1][j]);
                else dp[i][j] = s[i] == p[j] && i+1<=sLen && dp[i+1][j+1];
            }
        }

        return dp[0][0];
    }

方案2

    bool isMatch_2(string s, string p){
        if (s.size() == 0 && p.size() == 0) return true;
        int lastS = s.size(), lastP = p.size();
        int currS = 0, currP = 0;
        while (currS < s.size()){
            if (p[currP] == '*') lastP = currP, lastS = currS, currP++;
            else if (p[currP] == '?' || s[currS] == p[currP]) currP++, currS++;
            else if (lastS <= s.size()-1) currP = lastP, currS = ++lastS;
            else return false;
        }

        while (p[currP] == '*') currP++;
        return currP == p.size();
    }