LeetCode 2962: Count Subarrays Where Max Element Appears at Least K Times Solution

Master LeetCode problem 2962 (Count Subarrays Where Max Element Appears at Least K Times), a medium challenge, with our optimized solutions in Java, C++, and Python. Explore detailed explanations, test your code in our interactive editor, and prepare for coding interviews.

2962. Count Subarrays Where Max Element Appears at Least K Times

Medium

Array Sliding Window

Problem Explanation

Explanation:

To solve this problem, we can iterate through the array and for each element, we need to find the number of subarrays where the maximum element appears at least k times. We can achieve this by keeping track of the indices of the maximum element. We can utilize a monotonic decreasing stack to efficiently find the previous and next smaller elements for each element in the array.

Initialize a stack to store the indices of elements in descending order.
Iterate through the array and for each element:
- Pop elements from the stack that are smaller than the current element.
- For each popped element, calculate the number of subarrays with the maximum element as the popped element and update the count.
- Push the current element's index onto the stack.
After iterating through the array, repeat the same process for the remaining elements in the stack to handle subarrays that end at the last element.
Return the total count of subarrays where the maximum element appears at least k times.

The time complexity of this solution is O(n) where n is the length of the input array nums. The space complexity is also O(n) for the stack used to store indices.

Solution Code

class Solution {
    public int countSubarrays(int[] nums, int k) {
        int n = nums.length;
        int[] count = new int[n];
        Stack<Integer> stack = new Stack<>();
        int result = 0;

        for (int i = 0; i < n; i++) {
            while (!stack.isEmpty() && nums[i] > nums[stack.peek()]) {
                int idx = stack.pop();
                count[idx] = i - idx;
            }
            stack.push(i);
        }

        while (!stack.isEmpty()) {
            int idx = stack.pop();
            count[idx] = n - idx;
        }

        for (int i = 0; i < n; i++) {
            int left = i > 0 ? count[i - 1] : 0;
            int right = count[i];
            result += left * right;
        }

        return result;
    }
}

Try It Yourself

Loading code editor...

Frequently Asked Questions

How to solve LeetCode 2962 (Count Subarrays Where Max Element Appears at Least K Times)?

This page provides optimized solutions for LeetCode problem 2962 (Count Subarrays Where Max Element Appears at Least K Times) in Java, C++, and Python, along with a detailed explanation and an interactive code editor to test your code.

What is the time complexity of LeetCode 2962 (Count Subarrays Where Max Element Appears at Least K Times)?

The time complexity for LeetCode 2962 (Count Subarrays Where Max Element Appears at Least K Times) varies by solution. Check the detailed explanation section for specific complexities in Java, C++, and Python implementations.

Can I run code for LeetCode 2962 on DevExCode?

Yes, DevExCode provides an interactive code editor where you can write, test, and run your code for LeetCode 2962 in Java, C++, or Python.

Back to LeetCode Solutions