Maximum Number of Occurrences of a Substring - Problem

Given a string s, return the maximum number of occurrences of any substring under the following rules:

The number of unique characters in the substring must be less than or equal to maxLetters.
The substring size must be between minSize and maxSize inclusive.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Substring "aab" appears twice and has 2 unique characters (≤ maxLetters), length 3 (within range). Other valid substrings appear only once.

Example 2 — No Valid Substrings

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

› Output: 2

💡 Note: Substring "aaa" appears 2 times (positions 0-2 and 1-3), has 1 unique character (≤ maxLetters), length 3 (within range).

Example 3 — All Different Characters

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

› Output: 1

💡 Note: Substrings of length 2: "ab", "bc", "cd", "de" each have exactly 2 unique characters (≤ maxLetters), and each appears once. Maximum count is 1.

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ maxLetters ≤ 26
1 ≤ minSize ≤ maxSize ≤ min(26, s.length)

Visualization

Tap to expand

Asked in

F Facebook 12 G Google 8 a Amazon 6

The key insight is that shorter valid substrings always appear at least as frequently as longer ones containing them. Therefore, we only need to check substrings of minSize length. Best approach uses sliding window with hash map for O(n) time complexity with O(n) space.

Common Approaches

✓ Brute Force - Check All Substrings

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

For each possible substring length and starting position, check if it meets the criteria (unique characters ≤ maxLetters, size between minSize and maxSize), then count how many times each valid substring appears.

Optimized - Focus on Minimum Size

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

Key insight: If a substring of length minSize is valid, any longer substring containing it will appear less frequently. Therefore, we only need to check substrings of length minSize.

Sliding Window with Hash Map

⏱️ Time: O(n × (maxSize - minSize)) Space: O(n)

For each valid length, use a sliding window to generate all substrings of that length. Use a hash map to count character frequencies within the window and track valid substrings.

Brute Force - Check All Substrings — Algorithm Steps

Generate all substrings of valid lengths
Check unique character count for each
Count occurrences of each valid substring
Return maximum count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all substrings of valid lengths

Validate

Check unique character count

Count

Track occurrences of valid substrings

Code -

solution.c — C

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

int solution(char* s, int maxLetters, int minSize, int maxSize) {
    // Simple brute force implementation
    int n = strlen(s);
    int maxCount = 0;
    
    // For simplicity, use arrays to store substrings and counts
    char substrings[1000][100];
    int counts[1000];
    int numSubstrings = 0;
    
    // Generate all substrings of valid lengths
    for (int length = minSize; length <= maxSize; length++) {
        for (int i = 0; i <= n - length; i++) {
            char substring[100];
            strncpy(substring, s + i, length);
            substring[length] = '\0';
            
            // Count unique characters
            int uniqueChars[256] = {0};
            int uniqueCount = 0;
            for (int j = 0; j < length; j++) {
                if (!uniqueChars[(int)substring[j]]) {
                    uniqueChars[(int)substring[j]] = 1;
                    uniqueCount++;
                }
            }
            
            // Check if substring meets criteria
            if (uniqueCount <= maxLetters) {
                // Find if substring already exists
                int found = -1;
                for (int k = 0; k < numSubstrings; k++) {
                    if (strcmp(substrings[k], substring) == 0) {
                        found = k;
                        break;
                    }
                }
                
                if (found >= 0) {
                    counts[found]++;
                } else {
                    strcpy(substrings[numSubstrings], substring);
                    counts[numSubstrings] = 1;
                    numSubstrings++;
                }
            }
        }
    }
    
    // Find maximum count
    for (int i = 0; i < numSubstrings; i++) {
        if (counts[i] > maxCount) {
            maxCount = counts[i];
        }
    }
    
    return maxCount;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int maxLetters, minSize, maxSize;
    scanf("%d", &maxLetters);
    scanf("%d", &minSize);
    scanf("%d", &maxSize);
    
    int result = solution(s, maxLetters, minSize, maxSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: starting position, ending position, and character counting

✓ Linear Growth

Space Complexity

O(n²)

Hash map stores potentially O(n²) substrings

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Maximum Number of Occurrences of a Substring - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler