19.2.4 [LeetCode 44] 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

题意

通配符匹配，?代表单个特定字符，*代表若干长度的字符串

题解

一看就很像这题，所以想都没想用了dp，但是比较慢

class Solution {
public:
    bool isMatch(string s, string p) {
        s = " " + s, p = " " + p;
        int l1 = s.length(), l2 = p.length();
        vector<vector<bool>>dp(l1);
        for (int i = 0; i < l1; i++)dp[i].resize(l2);
        for (int i = 0; i < l1; i++)
            for (int j = 0; j < l2; j++)
                dp[i][j] = false;
        dp[0][0] = true;
        for (int i = 1; i < l2; i++) {
            if (p[i] == '*') {
                int j = 0;
                for (; j < l1; j++)
                    if (dp[j][i - 1])break;
                if (j < l1)
                    while (j < l1) {
                        dp[j][i] = true;
                        j++;
                    }
            }
            else if (p[i] == '?') {
                for (int j = 0; j < l1 - 1; j++)
                    if (dp[j][i - 1])
                        dp[j + 1][i] = true;
            }
            else {
                for (int j = 1; j < l1; j++)
                    if (s[j] == p[i] && dp[j - 1][i - 1])
                        dp[j][i] = true;
            }
        }
        return dp[l1 - 1][l2 - 1];
    }
};

我看见有解法是贪心，貌似比我这个快得多，但是我今天不想再看了，以后再说