Regular Expression Matching

Regular Expression Matching - Problem

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where:

'.' matches any single character
'*' matches zero or more of the preceding element

The matching should cover the entire input string (not partial).

Input & Output

Example 1 — Basic Star Pattern

$ Input: s = "aa", p = "a*"

› Output: true

💡 Note: The pattern 'a*' means zero or more 'a' characters. Since the string contains exactly two 'a's, the pattern matches.

Example 2 — Dot Wildcard

$ Input: s = "ab", p = ".*"

› Output: true

💡 Note: The pattern '.*' means zero or more of any character. This can match any string, including 'ab'.

Example 3 — No Match

$ Input: s = "mississippi", p = "mis*is*p*."

› Output: false

💡 Note: The pattern expects one more character at the end (the '.'), but the string ends after 'i'.

Constraints

1 ≤ s.length ≤ 20
1 ≤ p.length ≤ 30
s contains only lowercase English letters
p contains only lowercase English letters, '.', and '*'
'*' always appears after a preceding element

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is to break the problem into subproblems: does s[0..i] match p[0..j]? Handle the '*' character by trying both zero matches and one-or-more matches. Best approach is Dynamic Programming with O(m×n) time and space complexity.

Common Approaches

✓ Dynamic Programming (Bottom-Up)

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

Create a 2D DP table where dp[i][j] represents whether s[0..i-1] matches p[0..j-1]. Fill the table systematically from base cases to the final answer.

Recursion with Memoization

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

Same recursive approach but store results of helper(i,j) calls in a memoization table to avoid recalculating the same subproblems multiple times.

Recursive Brute Force

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

For each position in string and pattern, recursively check if they match. Handle '*' by trying both zero matches and one-or-more matches of the preceding character.

Dynamic Programming (Bottom-Up) — Algorithm Steps

Step 1: Create DP table with dimensions (m+1) × (n+1)
Step 2: Initialize base cases (empty string and pattern combinations)
Step 3: Fill table using recurrence relation handling '.' and '*'
Step 4: Return dp[m][n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base cases for empty strings

Fill Table

Use recurrence relation for each cell

Result

Bottom-right cell contains final answer

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 m = strlen(s), n = strlen(p);
    bool** dp = (bool**)malloc((m + 1) * sizeof(bool*));
    for (int i = 0; i <= m; i++) {
        dp[i] = (bool*)calloc(n + 1, sizeof(bool));
    }
    
    // Base case: empty string matches empty pattern
    dp[0][0] = true;
    
    // Handle patterns like a*, a*b*, a*b*c* that can match empty string
    for (int j = 2; j <= n; j++) {
        if (p[j - 1] == '*') {
            dp[0][j] = dp[0][j - 2];
        }
    }
    
    // Fill the DP table
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (p[j - 1] == '*') {
                // '*' matches zero occurrences
                dp[i][j] = dp[i][j - 2];
                // '*' matches one or more occurrences
                if (p[j - 2] == s[i - 1] || p[j - 2] == '.') {
                    dp[i][j] = dp[i][j] || dp[i - 1][j];
                }
            } else if (p[j - 1] == '.' || p[j - 1] == s[i - 1]) {
                // Character match or wildcard
                dp[i][j] = dp[i - 1][j - 1];
            }
        }
    }
    
    bool result = dp[m][n];
    
    // Free memory
    for (int i = 0; i <= m; 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(m×n)

Fill each cell of the m×n DP table exactly once

✓ Linear Growth

Space Complexity

O(m×n)

DP table of size (m+1)×(n+1) to store all subproblem results

⚡ Linearithmic Space

280.5K Views

High Frequency

~35 min Avg. Time

8.5K 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

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler