Shortest Subarray with Sum at Least K

Shortest Subarray with Sum at Least K - Problem

Array Binary Search Queue Sliding Window Heap (Priority Queue) Prefix Sum Monotonic Queue Hard

Given an integer array nums and an integer k, return the length of the shortest non-empty subarray of nums with a sum of at least k. If there is no such subarray, return -1.

A subarray is a contiguous part of an array.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: The subarray [4] has sum 4 which is ≥ 4, and length 1 is the shortest possible

Example 2 — Multiple Elements Needed

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

› Output: 3

💡 Note: The subarray [2,1,2] has sum 5 ≥ 4, and we need all 3 elements to reach the target

Example 3 — No Valid Subarray

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

› Output: -1

💡 Note: No subarray has sum ≥ 4, so we return -1

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

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

The key insight is to use prefix sums to convert the problem into finding the shortest distance between two prefix sum values that differ by at least k. The optimal approach uses a monotonic deque to maintain candidates efficiently. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

For each starting position, extend the subarray one element at a time until the sum reaches k or exceeds it. Track the minimum length found.

Prefix Sum with Monotonic Deque

⏱️ Time: O(n) Space: O(n)

Convert to prefix sum problem where we need to find shortest distance between prefix[j] - prefix[i] ≥ k. Use monotonic deque to maintain optimal candidates for minimum length.

Brute Force — Algorithm Steps

Start from each index i
Extend subarray to the right, calculating running sum
When sum ≥ k, update minimum length
Continue for all possible subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Check all subarrays starting from index 0

Extend

For each start, extend right until sum ≥ k

Result

Return minimum length found

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    int minLen = INT_MAX;
    
    for (int i = 0; i < numsSize; i++) {
        int currentSum = 0;
        for (int j = i; j < numsSize; j++) {
            currentSum += nums[j];
            if (currentSum >= k) {
                int len = j - i + 1;
                if (len < minLen) {
                    minLen = len;
                }
                break;
            }
        }
    }
    
    return minLen == INT_MAX ? -1 : minLen;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop n times, inner loop up to n times each

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

⚡ Linearithmic Space

78.4K Views

Medium Frequency

~35 min Avg. Time

2.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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler