Minimum Window Substring

Minimum Window Substring - Problem

Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window.

If there is no such substring, return the empty string "".

The testcases will be generated such that the answer is unique.

Input & Output

Example 1 — Basic Case

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

› Output: "BANC"

💡 Note: The minimum window substring "BANC" includes one 'A', one 'B', and one 'C' from t.

Example 2 — No Valid Window

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

› Output: ""

💡 Note: String s only has one 'a', but t requires two 'a's. No valid window exists.

Example 3 — Entire String

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

› Output: "a"

💡 Note: The minimum window is the entire string s, which is "a".

Constraints

1 ≤ s.length, t.length ≤ 10⁵
s and t consist of uppercase and lowercase English letters

Visualization

Tap to expand

Asked in

f Facebook 85 a Amazon 72 M Microsoft 68 G Google 65 🍎 Apple 45

The sliding window approach is optimal for this problem. The key insight is to use two pointers to maintain a dynamic window that expands when invalid and contracts when valid. Best approach uses hash maps to track character frequencies. Time: O(m + n), Space: O(m + n).

Common Approaches

✓ Brute Force - Check All Substrings

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

Generate all possible substrings of s and check if each contains all characters from t. Keep track of the shortest valid substring found.

Sliding Window with Hash Map

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

Maintain a sliding window using two pointers. Expand the right pointer to include more characters, contract the left pointer when window is valid. Use hash maps to track character frequencies.

Brute Force - Check All Substrings — Algorithm Steps

Generate all possible substrings of s
For each substring, count character frequencies
Check if substring contains all characters from t with required frequencies
Track the minimum length valid substring

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings of s

Check Each Substring

Verify if substring contains all characters from t

Track Minimum

Keep the shortest valid substring found

Code -

solution.c — C

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

char* solution(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 in t
    int tCount[256] = {0};
    for (int i = 0; i < tLen; i++) {
        tCount[(int)t[i]]++;
    }
    
    char* result = malloc(sLen + 1);
    result[0] = '\0';
    int minLen = INT_MAX;
    
    // Check all possible substrings
    for (int i = 0; i < sLen; i++) {
        for (int j = i + tLen; j <= sLen; j++) {
            int subCount[256] = {0};
            
            // Count characters in current substring
            for (int k = i; k < j; k++) {
                subCount[(int)s[k]]++;
            }
            
            // Check if substring contains all characters from t
            int valid = 1;
            for (int k = 0; k < 256; k++) {
                if (tCount[k] > subCount[k]) {
                    valid = 0;
                    break;
                }
            }
            
            if (valid && (j - i) < minLen) {
                minLen = j - i;
                strncpy(result, s + i, j - i);
                result[j - i] = '\0';
            }
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m² × n)

O(m²) substrings, each requiring O(n) to validate against t

✓ Linear Growth

Space Complexity

O(m + n)

Hash maps to store character frequencies

⚡ Linearithmic Space

336.8K Views

Very High Frequency

~25 min Avg. Time

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