Maximum Sum of Almost Unique Subarray - Practice Coding Problems

Maximum Sum of Almost Unique Subarray - Problem

You're given an integer array nums and two positive integers m and k. Your task is to find the maximum sum among all subarrays of length k that contain at least m distinct elements.

A subarray is considered "almost unique" if it has at least m different values. If no such subarray exists, return 0.

Example: Given nums = [2,6,7,3,1,7], m = 3, k = 4
The subarray [2,6,7,3] has 4 distinct elements (≥ 3) and sum = 18
The subarray [6,7,3,1] has 4 distinct elements (≥ 3) and sum = 17
The subarray [7,3,1,7] has 3 distinct elements (≥ 3) and sum = 18
Maximum sum = 18

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,6,7,3,1,7], m = 3, k = 4

› Output: 18

💡 Note: The subarrays of length 4 are: [2,6,7,3] (4 distinct, sum=18), [6,7,3,1] (4 distinct, sum=17), [7,3,1,7] (3 distinct, sum=18). All have ≥3 distinct elements, maximum sum is 18.

example_2.py — No Valid Subarray

$ Input: nums = [5,9,9,2,4,5,4], m = 1, k = 3

› Output: 23

💡 Note: All subarrays of length 3 have at least 1 distinct element. The maximum sum subarray is [9,9,5] with sum 23.

example_3.py — Edge Case

$ Input: nums = [1,1,1,7,8,9], m = 3, k = 4

› Output: 25

💡 Note: Only the subarray [1,7,8,9] has at least 3 distinct elements, with sum 1+7+8+9=25.

Constraints

1 ≤ k ≤ nums.length ≤ 10⁵
1 ≤ m ≤ k
1 ≤ nums[i] ≤ 10⁵
k is always less than or equal to the array length
m is always less than or equal to k

Visualization

Tap to expand

Understanding the Visualization

Set up initial tasting menu

Start with first k dishes, count cuisine types and total price

Slide your tasting selection

Add next dish, remove first dish from your selection

Update tracking efficiently

Adjust cuisine count and total price incrementally

Check diversity requirement

If cuisine variety ≥ m, compare with best price found so far

Key Takeaway

🎯 Key Insight: The sliding window technique allows us to efficiently maintain both the sum and distinct count as we move through the array, avoiding the need to recalculate everything from scratch for each position. By using a frequency map, we can add/remove elements in O(1) time and track distinct elements accurately.

Asked in

f Meta 42 G Google 38 a Amazon 35 ⊞ Microsoft 28

The optimal approach uses a sliding window technique with a frequency hash map to efficiently track distinct elements and sum. We maintain a window of size k, updating the frequency count and sum as we slide. This achieves O(n) time complexity compared to the brute force O(n*k) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(k)	Use sliding window technique with hash map to efficiently track distinct elements and sum
Brute Force (Check All Subarrays)	O(n*k)	O(k)	Check every possible subarray of length k and find the maximum sum among those with at least m distinct elements

Sliding Window (Optimal) — Algorithm Steps

Initialize sliding window for first k elements
Use frequency map to count distinct elements
Calculate initial sum and check if valid (distinct ≥ m)
Slide window: add new element, remove leftmost element
Update frequency map and sum incrementally
Track maximum sum among all valid windows

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Set up first k elements with frequency map

Slide Right

Add new element on right, update frequency and sum

Remove Left

Remove leftmost element, update frequency and sum

Check Validity

If distinct count ≥ m, update maximum sum

Code -

solution.c — C

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

#define MAX_VAL 100000

long long maximumSubarraySum(int* nums, int numsSize, int m, int k) {
    if (numsSize < k) return 0;
    
    // Use array as hash map (assuming nums[i] in reasonable range)
    int freq[MAX_VAL + 1] = {0};
    int distinctCount = 0;
    long long currentSum = 0;
    
    // Initialize first window
    for (int i = 0; i < k; i++) {
        if (freq[nums[i]] == 0) {
            distinctCount++;
        }
        freq[nums[i]]++;
        currentSum += nums[i];
    }
    
    long long maxSum = (distinctCount >= m) ? currentSum : 0;
    
    // Slide the window
    for (int i = k; i < numsSize; i++) {
        // Add new element
        int newElem = nums[i];
        if (freq[newElem] == 0) {
            distinctCount++;
        }
        freq[newElem]++;
        currentSum += newElem;
        
        // Remove leftmost element
        int oldElem = nums[i - k];
        currentSum -= oldElem;
        freq[oldElem]--;
        if (freq[oldElem] == 0) {
            distinctCount--;
        }
        
        // Update max sum if current window is valid
        if (distinctCount >= m && currentSum > maxSum) {
            maxSum = currentSum;
        }
    }
    
    return maxSum;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse the array once, and each element is added/removed from hash map at most once, each operation taking O(1) average time

✓ Linear Growth

Space Complexity

O(k)

Hash map stores at most k distinct elements in the current window

✓ Linear Space

42.4K Views

Medium-High Frequency

~18 min Avg. Time

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

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler