Maximum Number of Occurrences of a Substring

Maximum Number of Occurrences of a Substring - Problem

Maximum Number of Occurrences of a Substring

You're given a string s and three constraints: maxLetters, minSize, and maxSize. Your task is to find the maximum number of occurrences of any substring that satisfies all the following rules:

📏 Size constraint: The substring length must be between minSize and maxSize (inclusive)
🔤 Character constraint: The substring must contain at most maxLetters unique characters

Goal: Return the highest frequency count among all valid substrings. If no valid substring exists, return 0.

Example: For string "aababcaab" with maxLetters=2, minSize=3, maxSize=4, the substring "aab" appears 2 times and satisfies both constraints.

Input & Output

example_1.py — Basic Case

$ Input: s = "aababcaab", maxLetters = 2, minSize = 3, maxSize = 4

› Output: 2

💡 Note: The substring "aab" appears 2 times at positions 1-3 and 6-8. It has exactly 2 unique characters ('a' and 'b'), satisfying maxLetters=2 constraint.

example_2.py — No Valid Substrings

$ Input: s = "aaaa", maxLetters = 1, minSize = 3, maxSize = 3

› Output: 2

💡 Note: The substring "aaa" appears 2 times (positions 0-2 and 1-3). It has only 1 unique character, satisfying all constraints.

example_3.py — Complex Case

$ Input: s = "abcde", maxLetters = 2, minSize = 3, maxSize = 3

› Output: 0

💡 Note: No substring of length 3 has ≤ 2 unique characters. All 3-character substrings have exactly 3 unique characters, violating the maxLetters=2 constraint.

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ maxLetters ≤ 26
1 ≤ minSize ≤ maxSize ≤ min(26, s.length)
s consists of only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Understand constraints

Pattern must be minSize-maxSize long with ≤maxLetters unique characters

Key insight discovery

Realize shorter patterns appear at least as often as longer ones

Sliding window

Check only minimum length patterns using sliding window

Count and compare

Track frequencies and return the maximum

Key Takeaway

🎯 Key Insight: The optimal solution leverages the mathematical property that shorter substrings appear at least as frequently as longer ones, allowing us to focus only on minimum-length patterns for maximum efficiency.

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a key insight: if a substring of length k appears n times, any substring of length k-1 within it appears at least n times. Therefore, we only need to check substrings of minimum length using a sliding window approach, achieving O(n × minSize) time complexity instead of the brute force O(n³).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Sliding Window (Optimal)	O(n × minSize)	O(n)	Use sliding window to check only minimum length substrings for maximum efficiency
Brute Force (All Substrings)	O(n³)	O(n²)	Generate all possible substrings within size range and count valid ones

Optimized Sliding Window (Optimal) — Algorithm Steps

Use sliding window of size minSize only
For each window position, count unique characters
If unique characters <= maxLetters, increment frequency
Slide window one position and repeat
Return maximum frequency found

Visualization

Tap to expand

Step-by-Step Walkthrough

Key insight

If longer substring appears k times, shorter ones appear ≥k times

Sliding window

Use window of minSize only

Check constraints

Count unique characters in each window

Track frequencies

Count occurrences of valid substrings

Code -

solution.c — C

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

#define MAX_SUBSTRINGS 10000

struct Substring {
    char str[1001];
    int count;
};

int countUniqueChars(char* str, int len) {
    int chars[26] = {0};
    int unique = 0;
    
    for (int i = 0; i < len; i++) {
        if (chars[str[i] - 'a'] == 0) {
            chars[str[i] - 'a'] = 1;
            unique++;
        }
    }
    
    return unique;
}

int maxFreq(char* s, int maxLetters, int minSize, int maxSize) {
    struct Substring substrings[MAX_SUBSTRINGS];
    int substringCount = 0;
    int n = strlen(s);
    
    // Only check substrings of minSize (key insight!)
    for (int i = 0; i <= n - minSize; i++) {
        if (countUniqueChars(s + i, minSize) <= maxLetters) {
            char temp[1001];
            strncpy(temp, s + i, minSize);
            temp[minSize] = '\0';
            
            // Find or create substring entry
            int found = -1;
            for (int j = 0; j < substringCount; j++) {
                if (strcmp(substrings[j].str, temp) == 0) {
                    found = j;
                    break;
                }
            }
            
            if (found >= 0) {
                substrings[found].count++;
            } else {
                strcpy(substrings[substringCount].str, temp);
                substrings[substringCount].count = 1;
                substringCount++;
            }
        }
    }
    
    int maxCount = 0;
    for (int i = 0; i < substringCount; i++) {
        if (substrings[i].count > maxCount) {
            maxCount = substrings[i].count;
        }
    }
    
    return maxCount;
}

int main() {
    printf("%d\n", maxFreq("aababcaab", 2, 3, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × minSize)

Single pass through string × time to count characters in each window

✓ Linear Growth

Space Complexity

O(n)

Hash map to store substring frequencies

⚡ Linearithmic Space

25.5K Views

Medium Frequency

~15 min Avg. Time

850 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

Optimized Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler