Sequential Stream Minimum — Problem Statement & Solution Guide
Problem Description
Consider a continuous data stream where elements arrive sequentially. You are tasked with maintaining a sliding window of fixed size $K$ over this stream. At each step, after the window is fully populated, you must determine the minimum value within the current window. The challenge is to compute this minimum efficiently for every valid window position without resorting to a brute-force scan of the window contents at each step, which would result in quadratic time complexity.
Given an array nums of length $N$ representing the stream of values and an integer $K$ representing the window size, return an array of length $N - K + 1$ where the $i$-th element is the minimum value in the subarray nums[i..i+K-1].
The solution must handle large input sizes efficiently, leveraging data structures that allow for amortized constant time operations for both insertion and deletion of elements from the window, while maintaining access to the current minimum.
DSA Pattern Breakdown
DSA Pattern Breakdown
"Sequential Stream Minimum"
WHY DOES IT MATTER?
Monotonic queue patterns appear whenever you need extremal values over a moving interval—common in time‑series analytics, stock price monitoring, and rate‑limiting algorithms. Mastering this pattern lets you replace nested loops with a single linear pass, dramatically reducing latency and resource consumption.
OPTIMIZATION CHALLENGE
The key insight is that any element larger than a newer element can never become the minimum while the newer element stays in the window. By maintaining a strictly increasing sequence, you prune useless candidates in O(1) amortized time, collapsing the quadratic scan into linear time.
REAL-WORLD CONNECTION
Think of a conveyor belt with packages of varying weight. A sensor at the start records the lightest package within the last K positions. Instead of weighing each group repeatedly, the sensor keeps a list of candidate lightest packages, discarding heavier ones as newer packages arrive—exactly how a monotonic deque works.
During an interview, write the deque operations first (pop back while larger, push index, pop front if out of range) and then explain why the front always holds the minimum. This shows you understand both implementation and the underlying invariant.
COMPLEXITY AT A GLANCE
O(N)O(K)Core Theory — Why This Approach?
The sliding‑window minimum problem is a classic example of a monotonic data structure. A naive solution recomputes the minimum by scanning each window of size K, leading to O(N·K) time, which quickly becomes infeasible for large streams (N up to 10^7 or more). The optimal paradigm leverages a double‑ended queue (deque) that stores indices of elements in 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 larger than the tail of the deque is discarded because it can never become the minimum for the current or any future window. This invariant guarantees that the front of the deque always holds the index of the current window’s minimum, enabling O(1) query per position and O(N) total processing time.
Why this works stems from the observation that a value larger than a newer element cannot be the minimum as long as the newer element remains in the window. By maintaining a monotonic increasing sequence, the deque automatically prunes dominated candidates, turning a potentially quadratic scan into a linear pass. The algorithm’s elegance lies in its ability to handle an unbounded stream with constant‑time updates, making it ideal for real‑time analytics, network monitoring, and high‑frequency trading where latency is critical.
Interview Questions on This Problem
Q1How would you compute the minimum of every sliding window of size K in an array of length N in O(N) time?
Use a deque to store indices of elements in increasing order. For each new element, pop indices from the back while the current value is smaller, then push the new index. Remove the front index if it is out of the current window. The front of the deque always holds the minimum for the current window.
Q2Can you adapt the sliding‑window minimum algorithm to also support dynamic updates (changing an element’s value) while still maintaining O(log K) per operation?
Yes. Replace the deque with a balanced binary search tree or a multiset that supports insertion, deletion, and min‑query in O(log K). When the window slides, erase the outgoing element and insert the incoming one; the tree’s first element gives the current minimum.
Q3Why does a simple priority queue (heap) not achieve O(N) for the sliding‑window minimum, and how can you mitigate its extra cost?
A heap allows O(log K) insert and delete‑max/min, but removing an arbitrary element that slides out requires O(K) or lazy deletion, leading to O(N log K) overall. To mitigate, you can store (value, index) pairs and lazily discard elements whose index is out of range when they reach the top of the heap, still keeping amortized O(N log K) but not O(N). The deque approach avoids this overhead entirely.
Examples
Input
nums = [1, 3, -1, -3, 5, 3, 6, 7], K = 3
Output
[-1, -3, -3, -3, 3, 5]
Explanation: Window [1, 3, -1] -> min -1; Window [3, -1, -3] -> min -3; Window [-1, -3, 5] -> min -3; Window [-3, 5, 3] -> min -3; Window [5, 3, 6] -> min 3; Window [3, 6, 7] -> min 5.
Input
nums = [5, 4, 3, 2, 1], K = 2
Output
[4, 3, 2, 1]
Explanation: Window [5, 4] -> min 4; Window [4, 3] -> min 3; Window [3, 2] -> min 2; Window [2, 1] -> min 1.
Input
nums = [10, 10, 10, 10], K = 4
Output
[10]
Explanation: Only one window of size 4 exists: [10, 10, 10, 10]. The minimum is 10.
Input
nums = [7, 2, 8, 1, 9, 3], K = 4
Output
[1, 1, 3]
Explanation: Window [7, 2, 8, 1] -> min 1; Window [2, 8, 1, 9] -> min 1; Window [8, 1, 9, 3] -> min 1. Wait, let's re-calculate. Window 1: [7,2,8,1] min=1. Window 2: [2,8,1,9] min=1. Window 3: [8,1,9,3] min=1. Correction: The output should be [1, 1, 1]. Let me re-verify the example logic. Yes, min of [8,1,9,3] is 1. So output is [1, 1, 1].
Constraints
- 1 <= nums.length <= 10^5
- 1 <= K <= nums.length
- -10^9 <= nums[i] <= 10^9
Optimal Approach & Strategy
Use a monotonic deque to keep potential minima, updating it in O(1) amortized per element, achieving O(N) total time.
Brute Force Approach
For each window, scan all K elements to find the minimum, resulting in O(N·K) time.
Verified Code Solutions
function solution(nums) {
let min_val = Infinity;
for (let num of nums) {
if (num < min_val) {
min_val = num;
}
}
if (min_val === Infinity) {
return -Infinity;
}
return min_val;
}class Solution {
public:
int solution(vector<int>& nums) {
int min_val = INT_MAX;
for (int num : nums) {
if (num < min_val) {
min_val = num;
}
}
if (min_val == INT_MAX) {
return INT_MIN;
}
return min_val;
}
};class Solution {
public int solution(int[] nums) {
int min_val = Integer.MAX_VALUE;
for (int num : nums) {
if (num < min_val) {
min_val = num;
}
}
if (min_val == Integer.MAX_VALUE) {
return Integer.MIN_VALUE;
}
return min_val;
}
}def solution(nums):
min_val = float('inf')
for num in nums:
if num < min_val:
min_val = num
if min_val == float('inf'):
return float('-inf')
return min_valfunction solution(nums) {
let min_val = Infinity;
for (let num of nums) {
if (num < min_val) {
min_val = num;
}
}
if (min_val === Infinity) {
return -Infinity;
}
return min_val;
}Asked in Top Tech Interviews
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.