Minimum Window Subsequence - Practice Coding Problems

Minimum Window Subsequence - Problem

Imagine you're a detective looking through a long document (string s1) trying to find the shortest paragraph that contains all the clues you need in the exact order specified by your clue sequence (string s2).

Given two strings s1 and s2, find the minimum contiguous substring of s1 such that s2 is a subsequence of this substring. A subsequence means the characters appear in the same order but don't need to be consecutive.

Goal: Return the shortest window in s1 that contains s2 as a subsequence. If multiple windows have the same minimum length, return the leftmost one. If no such window exists, return an empty string.

Example: If s1 = "abcdebdde" and s2 = "bde", the answer is "bcde" because it's the shortest substring where we can find 'b', 'd', 'e' in that order.

Input & Output

example_1.py — Basic Example

$ Input: s1 = "abcdebdde", s2 = "bde"

› Output: "bcde"

💡 Note: The substring "bcde" is the shortest window in s1 that contains "bde" as a subsequence. We can pick 'b' at index 1, 'd' at index 3, and 'e' at index 4.

example_2.py — No Valid Window

$ Input: s1 = "jmeqksfrsdcmsiwvaovztaqenprpvnbstl", s2 = "u"

› Output: ""

💡 Note: There is no character 'u' in s1, so no substring can contain s2 as a subsequence.

example_3.py — Multiple Windows

$ Input: s1 = "abcdebdde", s2 = "bd"

› Output: "bcd"

💡 Note: Multiple valid windows exist: "bcd" (length 3), "bcde" (length 4), "bcdeb" (length 5), etc. We return "bcd" as it's the shortest.

Visualization

Tap to expand

Understanding the Visualization

🔍 Expand Search Area

Move your magnifying glass right until you've found all clues in sequence

🎯 Shrink to Minimum

Contract from the left while keeping all clues visible

📝 Record Best Result

Save the smallest valid section and continue searching

🔄 Repeat Process

Move to next position and repeat until entire document scanned

Key Takeaway

🎯 Key Insight: The two-phase approach (expand-then-shrink) ensures we find all possible minimum windows efficiently without redundant checking!

Time & Space Complexity

Time Complexity

⏱️

O(m·n)

m iterations of the outer loop, each doing O(n) work to scan s1

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and variables

✓ Linear Space

Constraints

1 ≤ s1.length ≤ 2 × 10⁴
1 ≤ s2.length ≤ 100
s1 and s2 consist of lowercase English letters only
If no valid window exists, return empty string
If multiple minimum windows exist, return the leftmost one

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a two-pointer sliding window technique with expand-and-shrink phases. We expand the right boundary until finding a valid window containing s2 as a subsequence, then shrink from the left to minimize the window. This achieves O(m·n) time complexity with O(1) space, making it efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Expand & Shrink)	O(m·n)	O(1)	Use two pointers to find valid windows by expanding right, then shrinking left
Dynamic Programming (2D Table)	O(m·n)	O(m·n)	Build a 2D DP table to track minimum window endings at each position

Two Pointers (Expand & Shrink) — Algorithm Steps

Start with left and right pointers at the beginning
Expand right pointer until we find a valid window (s2 is subsequence)
Once valid window found, try to shrink from left while maintaining validity
Record the minimum window and continue searching
Use backward matching to efficiently shrink the window

Visualization

Tap to expand

Step-by-Step Walkthrough

Expand Phase

Move right pointer until s2 is found as subsequence

Shrink Phase

Move left boundary rightward while keeping s2 as subsequence

Record & Repeat

Save minimum window and continue from next position

Code -

solution.c — C

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

char* findShortestWay(const char* s1, const char* s2) {
    int m = strlen(s1), n = strlen(s2);
    if (n == 0) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    int minLen = INT_MAX;
    int bestStart = -1, bestEnd = -1;
    
    int i = 0;
    while (i < m) {
        // Phase 1: Expand right to find valid window
        int j = i;
        int tIdx = 0;
        
        while (j < m && tIdx < n) {
            if (s1[j] == s2[tIdx]) {
                tIdx++;
            }
            j++;
        }
        
        if (tIdx < n) break;
        
        // Phase 2: Shrink left to minimize window
        int end = j - 1;
        tIdx = n - 1;
        
        while (end >= i && tIdx >= 0) {
            if (s1[end] == s2[tIdx]) {
                tIdx--;
            }
            end--;
        }
        
        int start = end + 1;
        
        if (j - start < minLen) {
            minLen = j - start;
            bestStart = start;
            bestEnd = j;
        }
        
        i = start + 1;
    }
    
    if (bestStart == -1) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    char* result = malloc(bestEnd - bestStart + 1);
    strncpy(result, s1 + bestStart, bestEnd - bestStart);
    result[bestEnd - bestStart] = '\0';
    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 = findShortestWay(s1, s2);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m·n)

m iterations of the outer loop, each doing O(n) work to scan s1

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and variables

✓ Linear Space

Constraints

1 ≤ s1.length ≤ 2 × 10⁴
1 ≤ s2.length ≤ 100
s1 and s2 consist of lowercase English letters only
If no valid window exists, return empty string
If multiple minimum windows exist, return the leftmost one

34.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Expand & Shrink) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler