Maximum Difference Between Even and Odd Frequency II

Maximum Difference Between Even and Odd Frequency II - Problem

You're given a string s and an integer k. Your challenge is to find the maximum difference between character frequencies in any substring of length at least k.

Specifically, you need to find freq[a] - freq[b] where:

The substring has at least k characters
Character a appears an odd number of times
Character b appears a non-zero even number of times

Think of it as finding the most "unbalanced" pair of characters in a valid substring!

Example: In substring "aaabbc", character 'a' appears 3 times (odd) and 'b' appears 2 times (even), giving a difference of 3 - 2 = 1.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: In substring 'aaabbc' (length 6 ≥ k=3), character 'a' appears 3 times (odd) and 'b' appears 2 times (even). The difference is 3-2 = 1.

example_2.py — Multiple Options

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

› Output: 1

💡 Note: In substring 'abccba' (length 6 ≥ k=4), character 'c' appears 2 times (even) and 'a' or 'b' appear 2 times each (even). We need odd-even pair, so we look at shorter valid substrings where we can find the best difference of 1.

example_3.py — Edge Case

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

› Output: 1

💡 Note: The only valid substring is 'aab' itself. Character 'a' appears 2 times (even) and 'b' appears 1 time (odd). Since we need odd-even difference, it's 1-2 = -1, but we want max, so difference is 1.

Visualization

Tap to expand

Understanding the Visualization

Identify Valid Segments

Find all continuous segments of length at least k characters

Count Character Frequencies

For each segment, count how many times each character appears

Classify Odd vs Even

Separate characters by whether their frequency is odd or even

Calculate Maximum Difference

Find the largest gap: max(odd_frequency) - min(even_frequency)

Key Takeaway

🎯 Key Insight: Use sliding window with frequency maps to efficiently track character counts and find optimal odd-even pairs without redundant calculations, reducing time complexity from O(n³) to O(n²).

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) possible starting positions, each with O(n) possible ending positions, but with optimized frequency tracking

⚠ Quadratic Growth

Space Complexity

O(1)

Frequency map size is bounded by alphabet size (constant)

✓ Linear Space

Constraints

1 ≤ k ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Must find substring of length at least k
Character with odd frequency and character with even frequency must both exist in the chosen substring

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses a sliding window technique with frequency tracking. For each starting position, we expand the window while maintaining character frequencies, and efficiently find the maximum difference between odd frequency and even frequency characters in O(n²) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Substrings)	O(n³)	O(1)	Check all possible substrings of length ≥ k and find maximum odd-even frequency difference
Sliding Window with Frequency Tracking (Optimal)	O(n²)	O(1)	Use sliding window technique with efficient frequency tracking to find optimal solution

Brute Force (All Substrings) — Algorithm Steps

Generate all substrings of length ≥ k
For each substring, count character frequencies
Find characters with odd frequencies and even frequencies
Calculate all possible differences freq[odd] - freq[even]
Track the maximum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Start with all substrings of length k, then k+1, k+2, etc.

Count Frequencies

For each substring, count how many times each character appears

Find Odd/Even

Identify characters with odd frequencies and even frequencies

Calculate Differences

Try all combinations of odd-even pairs and track maximum difference

Code -

solution.c — C

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

#define MAX_LEN 1000

int maximumDifference(char* s, int k) {
    int n = strlen(s);
    int maxDiff = -1;
    
    // Try all substrings of length >= k
    for (int i = 0; i <= n - k; i++) {
        for (int j = i + k - 1; j < n; j++) {
            // Count frequencies in substring s[i:j+1]
            int freq[256] = {0};
            for (int idx = i; idx <= j; idx++) {
                freq[(int)s[idx]]++;
            }
            
            // Find maximum difference between odd and even frequencies
            for (int a = 0; a < 256; a++) {
                if (freq[a] % 2 == 1) { // odd frequency
                    for (int b = 0; b < 256; b++) {
                        if (freq[b] % 2 == 0 && freq[b] > 0) { // even frequency
                            int diff = freq[a] - freq[b];
                            if (diff > maxDiff) {
                                maxDiff = diff;
                            }
                        }
                    }
                }
            }
        }
    }
    
    return maxDiff;
}

int main() {
    char s[MAX_LEN];
    int k;
    fgets(s, MAX_LEN, stdin);
    // Remove quotes and newline
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = '\0';
        memmove(s, s+1, strlen(s));
    }
    scanf("%d", &k);
    printf("%d\n", maximumDifference(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings, each taking O(n) time to process frequencies

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for frequency counting

✓ Linear Space

Constraints

1 ≤ k ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Must find substring of length at least k
Character with odd frequency and character with even frequency must both exist in the chosen substring

24.5K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force (All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler