Count Subarrays Where Max Element Appears at Least K Times

Count Subarrays Where Max Element Appears at Least K Times - Problem

You're given an integer array nums and a positive integer k. Your task is to count how many subarrays contain the maximum element of the entire array at least k times.

A subarray is a contiguous sequence of elements within the array. For example, in array [3, 1, 5, 1, 5], the maximum element is 5, and you need to find all subarrays where 5 appears at least k times.

Key Points:

First identify the maximum element in the entire array
Then count subarrays where this max element appears ≥ k times
Consider all possible contiguous subsequences

This problem tests your understanding of subarrays and efficient counting techniques using sliding window approaches.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,3,2,3,3], k = 2

› Output: 6

💡 Note: Max element is 3. Subarrays with at least 2 occurrences of 3: [3,2,3], [3,2,3,3], [2,3,3], [3,3], [3,2,3,3], [1,3,2,3,3]. Total = 6 subarrays.

example_2.py — Single Max Element

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

› Output: 0

💡 Note: Max element is 4, which appears only once. No subarray can have 4 appearing at least 3 times, so result is 0.

example_3.py — All Same Elements

$ Input: nums = [5,5,5], k = 2

› Output: 3

💡 Note: Max element is 5 (appears 3 times). Subarrays with at least 2 occurrences: [5,5], [5,5], [5,5,5]. Total = 3 subarrays.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ nums.length
The array always contains at least one element

Visualization

Tap to expand

Understanding the Visualization

Identify VIPs

First pass identifies who the VIP guests are (maximum element value)

Track Positions

As you scan, keep track of where VIP guests are located

Smart Counting

When you have k VIPs in view, count all valid sections ending at current position

Efficient Result

Each position processed in O(1) time, total O(n) complexity

Key Takeaway

🎯 Key Insight: Instead of checking every section individually (slow), track VIP positions and count valid sections mathematically (fast)!

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a sliding window approach with position tracking. Instead of checking every subarray individually (O(n³)), we track positions of the maximum element and count valid subarrays ending at each position in O(n) time. The key insight is that when we have k max elements, all subarrays ending at the current position and starting at or before the (k-1)th max element position are valid.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window to efficiently count valid subarrays
Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray and count occurrences of max element

Sliding Window (Optimal) — Algorithm Steps

Find the maximum element in the array
Use a sliding window approach with two pointers
Track positions of max elements in current window
When we have k max elements, count valid subarrays
For each valid ending position, count subarrays that can start from positions 0 to the (k-1)th max element position

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Max Positions

Keep track of where maximum elements appear

Window with K Elements

When we have k max elements in our tracking

Count Valid Starts

Count how many valid starting positions exist

Accumulate Result

Add valid subarrays for current ending position

Code -

solution.c — C

long long countSubarrays(int* nums, int numsSize, int k) {
    if (numsSize == 0 || k <= 0) return 0;
    
    int maxVal = nums[0];
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > maxVal) {
            maxVal = nums[i];
        }
    }
    
    int* maxPositions = (int*)malloc(numsSize * sizeof(int));
    int posCount = 0;
    long long result = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == maxVal) {
            maxPositions[posCount++] = i;
        }
        
        // If we have at least k max elements
        if (posCount >= k) {
            // All subarrays ending at i that start at or before
            // the (posCount-k)th max element position are valid
            int validStartPositions = maxPositions[posCount - k] + 1;
            result += validStartPositions;
        }
    }
    
    free(maxPositions);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track window state

✓ Linear Space

73.8K Views

High Frequency

~25 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