Wildcard Matching

Wildcard Matching - Problem

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).

Input & Output

Example 1 — Basic Wildcard Matching

$ Input: s = "adceb", p = "*a*b*"

› Output: true

💡 Note: The first '*' matches "ad", 'a' matches 'a', the second '*' matches "ce", 'b' matches 'b', and the last '*' matches the empty string.

Example 2 — No Match

$ Input: s = "adceb", p = "*a*b"

› Output: false

💡 Note: Pattern ends with 'b' but string ends with 'b'. However, the pattern requires exact match of entire string, and there are extra characters after matching.

Example 3 — Question Mark Wildcard

$ Input: s = "cb", p = "?a"

› Output: false

💡 Note: '?' matches 'c', but 'a' doesn't match 'b', so the pattern fails.

Constraints

0 ≤ s.length, p.length ≤ 2000
s contains only lowercase English letters
p contains only lowercase English letters, '?' or '*'

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is that '*' can match empty string or any characters, creating multiple possibilities. The optimal approach uses 2D Dynamic Programming or Greedy with Backtracking. DP builds a table where dp[i][j] represents if s[0:i] matches p[0:j]. Time: O(n×m), Space: O(n×m) for DP or O(1) for greedy.

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n×m) Space: O(n×m)

Create a 2D DP table where dp[i][j] represents whether s[0...i-1] matches p[0...j-1]. Fill table bottom-up using recurrence relations.

Dynamic Programming with Memoization

⏱️ Time: O(n×m) Space: O(n×m)

Same recursive approach but store results in a 2D cache table to avoid recomputing the same (i,j) positions multiple times.

Greedy with Backtracking

⏱️ Time: O(n×m) Space: O(1)

Use two pointers to scan through string and pattern. Greedily match characters and '?'. When encountering '*', record position and try minimal match first, backtrack if needed.

Recursive Brute Force

⏱️ Time: O(2^(n+m)) Space: O(n+m)

For each character, try to match it directly or use wildcards. When encountering '*', recursively try matching it with empty string, one character, two characters, etc.

Bottom-Up Dynamic Programming — Algorithm Steps

Initialize DP table with base cases
Fill table row by row using recurrence
Handle '*' by checking empty match or character match
Return dp[n][m] for final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base

Set dp[0][0] = true and handle leading '*'

Fill Table

Use recurrence relations row by row

Get Answer

Return dp[n][m] as final result

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>

bool solution(const char* s, const char* p) {
    int n = strlen(s), m = strlen(p);
    // dp[i][j] = true if s[0:i] matches p[0:j]
    bool** dp = (bool**)malloc((n + 1) * sizeof(bool*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (bool*)calloc(m + 1, sizeof(bool));
    }
    
    // Base case: empty string matches empty pattern
    dp[0][0] = true;
    
    // Handle patterns starting with '*'
    for (int j = 1; j <= m; j++) {
        if (p[j-1] == '*') {
            dp[0][j] = dp[0][j-1];
        }
    }
    
    // Fill DP table
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (p[j-1] == '*') {
                // '*' can match empty string or current character
                dp[i][j] = dp[i][j-1] || dp[i-1][j];
            } else if (p[j-1] == '?' || p[j-1] == s[i-1]) {
                // Characters match
                dp[i][j] = dp[i-1][j-1];
            }
            // else: characters don't match, dp[i][j] remains false
        }
    }
    
    bool result = dp[n][m];
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char s[1000], p[1000];
    fgets(s, sizeof(s), stdin);
    fgets(p, sizeof(p), stdin);
    s[strcspn(s, "\n")] = 0;
    p[strcspn(p, "\n")] = 0;
    
    bool result = solution(s, p);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Two nested loops iterate through all n×m positions in DP table

✓ Linear Growth

Space Complexity

O(n×m)

2D DP table stores boolean results for all i×j combinations

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~35 min Avg. Time

3.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler