Minimum Window Subsequence

Minimum Window Subsequence - Problem

Given two strings s1 and s2, return the minimum contiguous substring of s1 such that s2 is a subsequence of this substring.

If no such window exists in s1 that covers all characters of s2, return an empty string "".

If there are multiple such minimum-length windows, return the one with the leftmost starting index.

Note: A subsequence is a sequence that can be derived from another sequence by deleting some (not necessarily consecutive) elements without changing the order of the remaining elements.

Input & Output

Example 1 — Basic Case

$ Input: s1 = "adbec", s2 = "abc"

› Output: "adbec"

💡 Note: The minimum window substring "adbec" contains "abc" as a subsequence: a→d→b→e→c matches a→b→c by taking positions 0, 2, 4.

Example 2 — No Valid Window

$ Input: s1 = "adc", s2 = "abc"

› Output: ""

💡 Note: There is no subsequence "abc" in "adc" because 'b' is missing, so return empty string.

Example 3 — Multiple Windows

$ Input: s1 = "abacbcab", s2 = "abc"

› Output: "abc"

💡 Note: Multiple valid windows exist: "abacbc" and "abc". We return "abc" as it's shorter and leftmost among equal-length options.

Constraints

1 ≤ s1.length ≤ 2000
1 ≤ s2.length ≤ 100
s1 and s2 consist of lowercase English letters only

Visualization

Tap to expand

Asked in

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

The key insight is to use a sliding window approach with two phases: expand to find a valid window containing the subsequence, then contract to minimize it. Best approach uses two pointers with expand-contract cycles. Time: O(mn), Space: O(1).

Common Approaches

✓ Brute Force - Check All Substrings

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

For each starting position in s1, try all possible ending positions and check if the substring contains s2 as a subsequence. Keep track of the minimum length window found.

Dynamic Programming - 2D Table

⏱️ Time: O(mn) Space: O(mn)

Build a 2D DP table where dp[i][j] represents the minimum window ending at s1[i] that contains s2[0:j] as subsequence. Fill the table bottom-up and track the global minimum.

Optimized Sliding Window

⏱️ Time: O(mn) Space: O(1)

Expand the right pointer to match all characters of s2 as a subsequence, then contract from the left to find the minimum window. Repeat this process to find the global minimum.

Brute Force - Check All Substrings — Algorithm Steps

Step 1: For each starting position i in s1
Step 2: For each ending position j >= i, extract substring s1[i:j+1]
Step 3: Check if s2 is a subsequence of this substring
Step 4: Update minimum window if current substring is shorter

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Try all possible start and end positions

Check Subsequence

For each substring, verify if s2 is a subsequence

Track Minimum

Keep the shortest valid window found

Code -

solution.c — C

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

int isSubsequence(const char* s, const char* t) {
    int i = 0, j = 0;
    int sLen = strlen(s), tLen = strlen(t);
    while (i < sLen && j < tLen) {
        if (s[i] == t[j]) {
            j++;
        }
        i++;
    }
    return j == tLen;
}

char* solution(const char* s1, const char* s2) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int minLen = INT_MAX;
    char* result = malloc(len1 + 1);
    result[0] = '\0';
    
    for (int i = 0; i < len1; i++) {
        for (int j = i; j < len1; j++) {
            char* substring = malloc(j - i + 2);
            strncpy(substring, s1 + i, j - i + 1);
            substring[j - i + 1] = '\0';
            
            if (isSubsequence(substring, s2)) {
                if (strlen(substring) < minLen) {
                    minLen = strlen(substring);
                    strcpy(result, substring);
                }
                // Don't break here - continue to find potentially shorter windows starting at i
            }
            free(substring);
        }
    }
    
    return result;
}

int main() {
    char s1[1001], s2[101];
    fgets(s1, sizeof(s1), stdin);
    fgets(s2, sizeof(s2), stdin);
    s1[strcspn(s1, "\n")] = 0;
    s2[strcspn(s2, "\n")] = 0;
    
    char* result = solution(s1, s2);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: start position O(n), end position O(n), subsequence check O(n)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

865 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

Brute Force - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler