Shortest Matching Substring

Shortest Matching Substring - Problem

You are given a string s and a pattern string p, where p contains exactly two '*' characters. The '*' in p matches any sequence of zero or more characters.

Return the length of the shortest substring in s that matches p. If there is no such substring, return -1.

Note: The empty substring is considered valid.

Input & Output

Example 1 — Basic Pattern Match

$ Input: s = "abcdef", p = "a*c*f"

› Output: 6

💡 Note: The shortest substring that matches pattern "a*c*f" is "abcdef" with length 6. The first '*' matches "b", the second '*' matches "de", giving us the pattern a(b)c(de)f.

Example 2 — Empty String Match

$ Input: s = "hello", p = "**"

› Output: 0

💡 Note: Pattern "**" matches any string including the empty substring. Since empty substring is valid and has length 0, the answer is 0.

Example 3 — No Match Found

$ Input: s = "abc", p = "a*z*c"

› Output: -1

💡 Note: No substring of "abc" can match pattern "a*z*c" because there's no 'z' character in the string. The pattern requires 'a', then any sequence, then 'z', then any sequence, then 'c'.

Constraints

1 ≤ s.length ≤ 1000
3 ≤ p.length ≤ 1000
p contains exactly two '*' characters
s and p consist of lowercase English letters and '*'

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 25

The key insight is to decompose the pattern with two wildcards into prefix, middle, and suffix parts. The optimal approach uses two pointers to find the minimum window containing all required parts. Time: O(n²), Space: O(1).

Common Approaches

✓ Binary Search on Answer Length

⏱️ Time: O(n² log n) Space: O(1)

Use binary search on the possible answer length from 0 to n. For each candidate length, check if there exists any substring of that length that matches the pattern with two wildcards.

Brute Force - Check All Substrings

⏱️ Time: O(n³) Space: O(1)

Generate all possible substrings of s and check each one against the pattern p with two wildcards. Return the length of the shortest matching substring.

Two Pointers - Pattern Decomposition

⏱️ Time: O(n²) Space: O(1)

Decompose the pattern into prefix, middle, and suffix parts. Use two pointers to find the shortest substring that contains all required parts in correct order.

Binary Search on Answer Length — Algorithm Steps

Step 1: Binary search on possible lengths from 0 to n
Step 2: For each length, check all substrings of that length
Step 3: Return the minimum valid length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search Setup

Search space from 0 to string length

Check Length

For each candidate length, check all substrings

Find Minimum

Binary search finds the minimum valid length

Code -

solution.c — C

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

int matchesPattern(const char* text, const char* pattern) {
    int starPositions[2];
    int starCount = 0;
    int patternLen = strlen(pattern);
    
    for (int i = 0; i < patternLen; i++) {
        if (pattern[i] == '*') {
            if (starCount < 2) starPositions[starCount] = i;
            starCount++;
        }
    }
    if (starCount != 2) return 0;
    
    int star1Pos = starPositions[0];
    int star2Pos = starPositions[1];
    int textLen = strlen(text);
    
    // Check prefix
    for (int i = 0; i < star1Pos; i++) {
        if (i >= textLen || text[i] != pattern[i]) return 0;
    }
    
    // Check suffix
    int suffixLen = patternLen - star2Pos - 1;
    for (int i = 0; i < suffixLen; i++) {
        if (textLen - suffixLen + i < 0 || text[textLen - suffixLen + i] != pattern[star2Pos + 1 + i]) {
            return 0;
        }
    }
    
    // Check middle part
    int middleLen = star2Pos - star1Pos - 1;
    if (middleLen == 0) return 1;
    
    char middle[1000];
    strncpy(middle, pattern + star1Pos + 1, middleLen);
    middle[middleLen] = '\0';
    
    char remaining[1000];
    int remainingStart = star1Pos;
    int remainingEnd = textLen - suffixLen;
    if (remainingEnd <= remainingStart) return middleLen == 0;
    
    strncpy(remaining, text + remainingStart, remainingEnd - remainingStart);
    remaining[remainingEnd - remainingStart] = '\0';
    
    return strstr(remaining, middle) != NULL;
}

int canFindMatchOfLength(char* s, char* p, int length) {
    int n = strlen(s);
    for (int i = 0; i <= n - length; i++) {
        char substring[1000];
        strncpy(substring, s + i, length);
        substring[length] = '\0';
        
        if (matchesPattern(substring, p)) {
            return 1;
        }
    }
    return 0;
}

int solution(char* s, char* p) {
    int n = strlen(s);
    int left = 0, right = n;
    int result = -1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canFindMatchOfLength(s, p, mid)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    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;
    
    printf("%d\n", solution(s, p));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(log n) binary search iterations, each taking O(n²) to check all substrings

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for binary search variables

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

856 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

Binary Search on Answer Length — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler