Maximum Difference Between Even and Odd Frequency II

Maximum Difference Between Even and Odd Frequency II - Problem

You are given a string s and an integer k. Your task is to find the maximum difference between the frequency of two characters, freq[a] - freq[b], in a substring subs of s, such that:

subs has a size of at least k
Character a has an odd frequency in subs
Character b has a non-zero even frequency in subs

Return the maximum difference.

Note that subs can contain more than 2 distinct characters.

Input & Output

Example 1 — Basic Case

$ Input: s = "aabbc", k = 3

› Output: -1

💡 Note: For all substrings of length >= 3: "aab" has a=2(even), b=1(odd), giving diff=1-2=-1. "abb" has a=1(odd), b=2(even), giving diff=1-2=-1. "bbc" has b=2(even), c=1(odd), giving diff=1-2=-1. "aabb" has all even frequencies, so invalid. "abbc" has a=1(odd), b=2(even), c=1(odd), giving max_odd=1, min_even=2, diff=-1. "aabbc" has a=2(even), b=2(even), c=1(odd), giving max_odd=1, min_even=2, diff=-1. The maximum difference is -1.

Example 2 — No Valid Combination

$ Input: s = "aaa", k = 2

› Output: -1

💡 Note: All possible substrings of length >= 2 are "aa", "aa", "aaa". In each case, 'a' has even frequency (2, 2, 3 respectively). Wait, 3 is odd! In "aaa": 'a' appears 3 times (odd). But we need both an odd-frequency character AND an even-frequency character. Since only 'a' exists and it has odd frequency, there's no even-frequency character, so return -1.

Example 3 — Multiple Characters

$ Input: s = "abcabc", k = 4

› Output: -1

💡 Note: For all substrings of length >= 4, we consistently get differences of -1 since the maximum odd frequency is 1 while minimum even frequency is 2. No substring gives a difference >= 0.

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ k ≤ s.length
s consists of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to systematically check all substrings of length at least k and find the maximum difference between an odd-frequency character and an even-frequency character. The brute force approach checks all possible substrings, while optimized approaches use sliding windows or character enumeration with prefix sums. Best approach is sliding window with incremental updates. Time: O(n²), Space: O(1).

Common Approaches

✓ Brute Force - Check All Substrings

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

For each possible substring of length at least k, count character frequencies and find the maximum difference between an odd-frequency character and an even-frequency character.

Optimized Sliding Window

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

Instead of regenerating frequency counts for each substring, maintain a sliding window and update frequencies incrementally as we expand and contract the window.

Prefix Sum with Character Enumeration

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

For each character, treat it as the potential odd-frequency character and use prefix sum arrays to efficiently count frequencies in any substring. This allows us to check all substrings more efficiently.

Brute Force - Check All Substrings — Algorithm Steps

Generate all substrings of length >= k
Count frequency of each character in substring
Find max odd frequency and max even frequency
Calculate difference and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all substrings of length >= k

Count Frequencies

For each substring, count character frequencies

Find Difference

Calculate max_odd - min_even for each substring

Code -

solution.c — C

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

int solution(char* s, int k) {
    int n = strlen(s);
    int maxDiff = -1;
    
    for (int i = 0; i < n; i++) {
        int freq[26] = {0};
        for (int j = i; j < n; j++) {
            freq[s[j] - 'a']++;
            if (j - i + 1 >= k) {
                int maxOdd = -1;
                int minEven = INT_MAX;
                
                for (int idx = 0; idx < 26; idx++) {
                    int f = freq[idx];
                    if (f > 0) {
                        if (f % 2 == 1) {  // odd frequency
                            if (f > maxOdd) maxOdd = f;
                        } else {  // even frequency
                            if (f < minEven) minEven = f;
                        }
                    }
                }
                
                if (maxOdd != -1 && minEven != INT_MAX) {
                    int diff = maxOdd - minEven;
                    if (diff > maxDiff) maxDiff = diff;
                }
            }
        }
    }
    
    return maxDiff;
}

int main() {
    char s[100001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;  // Remove newline
    
    scanf("%d", &k);
    
    int result = solution(s, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to count frequencies for each

⚠ Quadratic Growth

Space Complexity

O(1)

Only using frequency array of fixed size 26

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 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