Wildcard Matching

Wildcard Matching asks whether a pattern with ? and * wildcards matches an entire string. It is a classic 2-D dynamic-programming problem: the answer for the whole input is built from the answers for every pair of prefixes.

The slow way first

The tempting approach is recursion: at each character decide what * should eat, branching on every possibility. But a * can match 0, 1, 2, … characters, so naive recursion explores an exponential number of branches and re-solves the same (i, j) prefix pair over and over. For a long string with several stars it times out.

The question to ask: what sub-answers do I keep recomputing? Always the same thing — "does the first i characters of s match the first j characters of p?" There are only (n+1) × (m+1) such questions, so we compute each one once and store it.

The idea: a grid of prefix answers

Let dp[i][j] mean "does p[0..j) match s[0..i)?". Fill the grid row by row. The recurrence depends only on the last pattern character:

• If p[j-1] is *, it can consume one more character of s (look up dp[i-1][j]) or match the empty string (look up dp[i][j-1]). Either path winning means True.
• If p[j-1] is ? or equals s[i-1], the last characters line up, so inherit dp[i-1][j-1].
• Otherwise the characters disagree and dp[i][j] is False.

The seed is dp[0][0] = True (empty matches empty). The first row handles a pattern matched against the empty string: a leading run of * stays True, anything else turns False.

Walk through it

Step through the animation for s = "ab", p = "*b". We seed the corner, fill the top row (the leading * keeps it True), then fill each inner cell. At dp[2][2] the literal b matches s's last b, so it copies the diagonal dp[1][1] = True. The bottom-right cell is the final answer.

Pseudocode

dp[0][0] = True                          # empty pattern matches empty string
for j in 1..m:                           # pattern vs the empty string
    if p[j-1] == "*": dp[0][j] = dp[0][j-1]
    else:             dp[0][j] = False
for i in 1..n:
    for j in 1..m:
        if p[j-1] == "*":
            dp[i][j] = dp[i-1][j] or dp[i][j-1]   # consume OR empty
        else if p[j-1] == "?" or p[j-1] == s[i-1]:
            dp[i][j] = dp[i-1][j-1]               # chars line up
        else:
            dp[i][j] = False
return dp[n][m]

The Python solution

def is_match(s, p):
    n, m = len(s), len(p)
    dp = [[False] * (m + 1) for _ in range(n + 1)]
    dp[0][0] = True
    for j in range(1, m + 1):
        if p[j - 1] == '*':
            dp[0][j] = dp[0][j - 1]
        else:
            dp[0][j] = False
    for i in range(1, n + 1):
        for j in range(1, m + 1):
            if p[j - 1] == '*':
                dp[i][j] = dp[i - 1][j] or dp[i][j - 1]
            elif p[j - 1] == '?' or p[j - 1] == s[i - 1]:
                dp[i][j] = dp[i - 1][j - 1]
            else:
                dp[i][j] = False
    return dp[n][m]

• dp is an (n+1) × (m+1) table; row i, column j answers the prefix question for lengths i and j.
• dp[0][0] = True is the seed — an empty pattern matches an empty string.
• The first loop fills the top row: only a leading run of * can match the empty string, so the value carries left-to-right while we see stars and drops to False after.
• Line 13 is the * branch — the two-way OR is the heart of the algorithm: consume one char (dp[i-1][j]) or match empty (dp[i][j-1]).
• Line 15 handles ? and an exact character match by inheriting the diagonal dp[i-1][j-1].
• dp[n][m] is whether the whole pattern matches the whole string.

Complexity

We trade an O(n·m) table for a dramatic speed-up. The table can be shrunk to a single row (O(m) space) since each cell only reads the current and previous row, but the full grid is clearer to reason about.

When this pattern shows up

Practice