Minimum Window Substring - Practice Coding Problems

Minimum Window Substring - Problem

Find the Smallest Window Containing All Characters

You're given two strings: a source string s and a target string t. Your mission is to find the shortest contiguous substring within s that contains every character from t (including duplicates).

Think of it as finding the smallest "net" that can capture all the required "fish" from the target string. If no such window exists, return an empty string.

Key Points:
• The window must contain all characters from t
• Duplicate characters in t must appear at least that many times in the window
• Among all valid windows, return the shortest one
• The answer is guaranteed to be unique

Example: If s = "ADOBECODEBANC" and t = "ABC", the minimum window is "BANC".

Input & Output

example_1.py — Basic Case

$ Input: s = "ADOBECODEBANC", t = "ABC"

› Output: "BANC"

💡 Note: The minimum window substring "BANC" includes all characters from "ABC". Other valid windows like "ADOBEC" are longer.

example_2.py — Single Character

$ Input: s = "a", t = "a"

› Output: "a"

💡 Note: The entire string s is the minimum window containing all characters of t.

example_3.py — No Valid Window

$ Input: s = "a", t = "aa"

› Output: ""

💡 Note: There's no substring in s that contains two 'a' characters, so return empty string.

Visualization

Tap to expand

Understanding the Visualization

Setup Target

Count all the stars (characters) you need to find

Expand Window

Widen your telescope view until you can see all required stars

Contract Window

Narrow the view while keeping all stars visible

Track Minimum

Remember the smallest window that worked

Continue Sliding

Move the window and repeat until you've checked the entire sky

Key Takeaway

🎯 Key Insight: The sliding window technique transforms an O(n³) brute force approach into an elegant O(n) solution by intelligently expanding and contracting a single window, ensuring each character is visited at most twice!

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

One pass through string s (n) plus one pass to build frequency map of t (m)

✓ Linear Growth

Space Complexity

O(m + k)

Hash maps for character frequencies, where k is the number of unique characters

✓ Linear Space

Constraints

m == s.length
n == t.length
1 ≤ m, n ≤ 10⁵
s and t consist of uppercase and lowercase English letters
The answer is guaranteed to be unique

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses the sliding window technique with hash maps to track character frequencies. We expand the window with the right pointer until all characters from t are included, then contract with the left pointer to minimize the window size. This achieves O(n) time complexity by visiting each character at most twice.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Map (Optimal)	O(n + m)	O(m + k)	Use expanding and contracting sliding window with character frequency tracking
Brute Force (Check All Substrings)	O(n³)	O(m + n)	Check every possible substring to find the minimum window containing all characters

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Create frequency map for characters in target string t
Use two pointers (left, right) to maintain a sliding window
Expand right pointer until window contains all required characters
Once valid, try to contract from left while maintaining validity
Track the minimum valid window found during the process
Return the minimum window substring

Visualization

Tap to expand

Step-by-Step Walkthrough

Expand Right

Move right pointer until window contains all characters from t

Contract Left

Move left pointer to minimize window while keeping it valid

Update Minimum

Record the shortest valid window found so far

Continue Process

Repeat expand/contract until right pointer reaches end

Code -

solution.c — C

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

char* minWindow(char* s, char* t) {
    int sLen = strlen(s);
    int tLen = strlen(t);
    
    if (sLen == 0 || tLen == 0 || sLen < tLen) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    // Count characters needed from t
    int need[256] = {0};
    int required = 0;
    for (int i = 0; i < tLen; i++) {
        if (need[t[i]] == 0) required++;
        need[t[i]]++;
    }
    
    // Sliding window variables
    int left = 0;
    int minLen = INT_MAX;
    int minStart = 0;
    int formed = 0;
    
    // Array to keep count of characters in current window
    int windowCounts[256] = {0};
    
    for (int right = 0; right < sLen; right++) {
        // Add character from right to the window
        char c = s[right];
        windowCounts[c]++;
        
        // If current character's frequency matches the desired count in t
        if (need[c] > 0 && windowCounts[c] == need[c]) {
            formed++;
        }
        
        // Try to contract the window from left
        while (left <= right && formed == required) {
            c = s[left];
            
            // Save the smallest window
            if (right - left + 1 < minLen) {
                minLen = right - left + 1;
                minStart = left;
            }
            
            // Remove from left of our window
            windowCounts[c]--;
            if (need[c] > 0 && windowCounts[c] < need[c]) {
                formed--;
            }
            
            left++;
        }
    }
    
    if (minLen == INT_MAX) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    char* result = malloc(minLen + 1);
    strncpy(result, s + minStart, minLen);
    result[minLen] = '\0';
    return result;
}

int main() {
    char s[1001], t[1001];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    
    // Remove newlines
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    
    char* result = minWindow(s, t);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

One pass through string s (n) plus one pass to build frequency map of t (m)

✓ Linear Growth

Space Complexity

O(m + k)

Hash maps for character frequencies, where k is the number of unique characters

✓ Linear Space

Constraints

m == s.length
n == t.length
1 ≤ m, n ≤ 10⁵
s and t consist of uppercase and lowercase English letters
The answer is guaranteed to be unique

89.2K Views

Very High Frequency

~25 min Avg. Time

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

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler