Centroid Tree Metric Analyzer 4 — Problem Statement & Solution Guide

StackHardMonotonic Queue Sliding Horizon

TimeO(N)

SpaceO(K)

Problem Description

You are given an integer array nums of length N and a positive integer K (1 ≤ K ≤ N). For every contiguous sub‑array of length K, compute the maximum element and output all these maxima in the order of their appearance. The required time complexity is O(N) and the auxiliary space must be O(K). Implement the solution using a monotonic decreasing deque (also known as a monotonic queue) that maintains candidate maximums for the current sliding window.

DSA Pattern Breakdown

"Centroid Tree Metric Analyzer 4"

hard

WHY DOES IT MATTER?

The monotonic queue pattern captures the essence of maintaining a dynamic ordering of candidates where only the most relevant elements survive. It is a cornerstone for many sliding‑window, range‑query, and online‑stream problems where O(N) performance is mandatory.

OPTIMIZATION CHALLENGE

The key insight is that any element smaller than a newly arrived element can never become the maximum for the current or any future window, so it can be safely removed immediately, reducing redundant comparisons.

REAL-WORLD CONNECTION

Think of a real‑time traffic monitoring dashboard that continuously shows the fastest vehicle speed over the last K minutes. As new speed reports arrive, older ones expire, and slower reports are discarded because a faster vehicle already dominates the view—mirroring the deque’s eviction policy.

During an interview, implement the deque using a simple array with head/tail pointers or a built‑in double‑ended queue. Focus on correctly handling index expiration before accessing the front for the answer.

COMPLEXITY AT A GLANCE

⏱ Time:O(N)

💾 Space:O(K)

Core Theory — Why This Approach?

The sliding‑window maximum problem asks for the greatest element in every contiguous sub‑array of size K. A naïve scan of each window costs O(K) per window, leading to O(N·K) total time, which is prohibitive when N and K are large (e.g., N=10^6). The optimal paradigm leverages a monotonic decreasing deque (also called a monotonic queue) that stores indices of elements in non‑increasing order of their values. As the window slides, elements that fall out of the window are removed from the front, and any new element that is smaller than the deque’s tail is simply appended, while larger elements purge smaller ones from the tail because they can never become a maximum for the current or any future window. This invariant guarantees that the deque’s front always holds the index of the current window’s maximum, enabling O(1) retrieval per step.

Maintaining the deque in this way yields a linear O(N) traversal: each array element is inserted and removed at most once, so the total number of deque operations is bounded by 2N. The auxiliary space is limited to O(K) because the deque never holds more than K indices—the window size—ensuring the algorithm meets the strict space constraint. This approach exemplifies how a carefully chosen data structure can transform a seemingly quadratic problem into a linear one.

Interview Questions on This Problem

Q1How does a monotonic decreasing deque guarantee O(N) time for the sliding‑window maximum problem?

Each array element is pushed to the deque exactly once and popped at most once (either when it leaves the window or when a larger element arrives and evicts smaller ones). Hence the total number of operations is linear in N, giving O(N) time.

Q2Can the sliding‑window maximum be solved with a segment tree or a heap in O(N log K) time, and why is the deque preferred?

Yes, a segment tree or a max‑heap can answer each window in O(log K), leading to O(N log K) overall. However, the deque achieves O(N) with lower constant factors and O(K) space, making it more suitable for real‑time or memory‑constrained environments.

Q3What modifications are needed to adapt the monotonic queue solution to compute sliding‑window minimums instead of maximums?

Replace the decreasing order invariant with an increasing order invariant: when inserting a new element, remove all elements from the tail that are larger than the new value. The front of the deque will then hold the index of the minimum for the current window.

Examples

Example 1

Input

nums = [4, 2, 12, 3, 8, 7, 5], K = 3

Output

[12, 12, 12, 8, 8]

Explanation: Window positions: 1. [4,2,12] → max = 12 (deque stores 12) 2. [2,12,3] → 12 remains at front, max = 12 3. [12,3,8] → 12 still in window, max = 12 4. [3,8,7] → 12 slides out, deque now holds 8, max = 8 5. [8,7,5] → 8 stays, max = 8 Thus the sequence of maxima is [12,12,12,8,8].

Example 2

Input

nums = [9, 1, 5, 3, 6, 2, 8, 4], K = 4

Output

[9, 6, 6, 8, 8]

Explanation: Sliding windows of size 4: - [9,1,5,3] → max = 9 - [1,5,3,6] → 9 leaves, 6 becomes front, max = 6 - [5,3,6,2] → max = 6 - [3,6,2,8] → 8 enters and becomes front, max = 8 - [6,2,8,4] → 8 stays, max = 8 Collected maxima: [9,6,6,8,8].

Example 3

Input

nums = [-2, -7, -1, -3, -4, -5], K = 2

Output

[-2, -1, -1, -3, -4]

Explanation: Windows: - [-2,-7] → max = -2 - [-7,-1] → -7 drops, -1 becomes max - [-1,-3] → max = -1 - [-3,-4] → max = -3 - [-4,-5] → max = -4 Resulting list of maxima: [-2,-1,-1,-3,-4].

Constraints

1 <= N <= 2*10^5
1 <= K <= N
-10^9 <= nums[i] <= 10^9
The algorithm must run in O(N) time and O(K) extra space.

Optimal Approach & Strategy

Maintain a monotonic decreasing deque to keep potential maxima; each element is inserted and removed at most once, achieving O(N) time and O(K) space.

Brute Force Approach

For each window, scan all K elements to find the maximum, resulting in O(N·K) time.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(N)

function solution(nums) {
   let prefixSums = [nums[0]];
   for (let i = 1; i < nums.length; i++) {
       prefixSums.push(prefixSums[i - 1] + nums[i]);
   }
   let maxSum = -Infinity;
   let queue = [0];
   for (let i = 1; i < prefixSums.length; i++) {
       while (queue.length > 0 && prefixSums[i] - prefixSums[queue[0]] <= 0) {
           queue.shift();
       }
       while (queue.length > 0 && prefixSums[queue[queue.length - 1]] < prefixSums[i]) {
           queue.pop();
       }
       queue.push(i);
       maxSum = Math.max(maxSum, prefixSums[i] - prefixSums[queue[0]]);
   }
   return maxSum;
}

class Solution {
   public:
   int solution(vector<int>& nums) {
       vector<int> prefixSums(nums.size());
       prefixSums[0] = nums[0];
       for (int i = 1; i < nums.size(); i++) {
           prefixSums[i] = prefixSums[i - 1] + nums[i];
       }
       int maxSum = INT_MIN;
       deque<int> queue;
       queue.push_back(0);
       for (int i = 1; i < prefixSums.size(); i++) {
           while (!queue.empty() && prefixSums[i] - prefixSums[queue.front()] <= 0) {
               queue.pop_front();
           }
           while (!queue.empty() && prefixSums[queue.back()] < prefixSums[i]) {
               queue.pop_back();
           }
           queue.push_back(i);
           maxSum = max(maxSum, prefixSums[i] - prefixSums[queue.front()]);
       }
       return maxSum;
   }
}

class Solution {
   public int solution(int[] nums) {
       int[] prefixSums = new int[nums.length];
       prefixSums[0] = nums[0];
       for (int i = 1; i < nums.length; i++) {
           prefixSums[i] = prefixSums[i - 1] + nums[i];
       }
       int maxSum = Integer.MIN_VALUE;
       Deque<Integer> queue = new ArrayDeque<>();
       queue.add(0);
       for (int i = 1; i < prefixSums.length; i++) {
           while (!queue.isEmpty() && prefixSums[i] - prefixSums[queue.peekFirst()] <= 0) {
               queue.removeFirst();
           }
           while (!queue.isEmpty() && prefixSums[queue.peekLast()] < prefixSums[i]) {
               queue.removeLast();
           }
           queue.add(i);
           maxSum = Math.max(maxSum, prefixSums[i] - prefixSums[queue.peekFirst()]);
       }
       return maxSum;
   }
}

def solution(nums):
   prefixSums = [nums[0]]
   for i in range(1, len(nums)):
       prefixSums.append(prefixSums[i - 1] + nums[i])
   maxSum = float('-inf')
   queue = [0]
   for i in range(1, len(prefixSums)):
       while queue and prefixSums[i] - prefixSums[queue[0]] <= 0:
           queue.pop(0)
       while queue and prefixSums[queue[-1]] < prefixSums[i]:
           queue.pop()
       queue.append(i)
       maxSum = max(maxSum, prefixSums[i] - prefixSums[queue[0]])
   return maxSum

function solution(nums) {
   let prefixSums = [nums[0]];
   for (let i = 1; i < nums.length; i++) {
       prefixSums.push(prefixSums[i - 1] + nums[i]);
   }
   let maxSum = -Infinity;
   let queue = [0];
   for (let i = 1; i < prefixSums.length; i++) {
       while (queue.length > 0 && prefixSums[i] - prefixSums[queue[0]] <= 0) {
           queue.shift();
       }
       while (queue.length > 0 && prefixSums[queue[queue.length - 1]] < prefixSums[i]) {
           queue.pop();
       }
       queue.push(i);
       maxSum = Math.max(maxSum, prefixSums[i] - prefixSums[queue[0]]);
   }
   return maxSum;
}

Asked in Top Tech Interviews

MicrosoftRazorpay

Solve in Interative Editor

Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.

Centroid Tree Metric Analyzer 4 Solution

Problem Statement

Input

Output

Input

Output

Input

Output

Constraints

More Stack

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

Centroid Tree Metric Analyzer 4 — Problem Statement & Solution Guide

Problem Description

DSA Pattern Breakdown

Core Theory — Why This Approach?

Interview Questions on This Problem

Examples

Constraints

Optimal Approach & Strategy

Brute Force Approach

Verified Code Solutions

Asked in Top Tech Interviews

Solve in Interative Editor