Kth Smallest Subarray Sum

Kth Smallest Subarray Sum - Problem

Given an integer array nums of length n and an integer k, return the kth smallest subarray sum.

A subarray is defined as a non-empty contiguous sequence of elements in an array. A subarray sum is the sum of all elements in the subarray.

Note: Subarrays are ordered by their sum values in ascending order. If two subarrays have the same sum, they are considered equal for ranking purposes.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: All subarrays: [2]→2, [2,1]→3, [2,1,3]→6, [1]→1, [1,3]→4, [3]→3. Sorted sums: [1,2,3,3,4,6]. The 4th smallest is 3.

Example 2 — Small Array

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

› Output: 1

💡 Note: Subarrays: [1]→1, [1,2]→3, [2]→2. Sorted: [1,2,3]. The 1st smallest is 1.

Example 3 — Negative Numbers

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

› Output: -2

💡 Note: All subarrays: [-1]→-1, [-1,2]→1, [-1,2,-3]→-2, [2]→2, [2,-3]→-1, [-3]→-3. Sorted: [-3,-2,-1,-1,1,2]. The 2nd smallest is -2.

Constraints

1 ≤ nums.length ≤ 2000
-5 × 10⁴ ≤ nums[i] ≤ 5 × 10⁴
1 ≤ k ≤ nums.length × (nums.length + 1) / 2

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to use binary search on the answer space rather than generating all sums explicitly. The binary search approach efficiently finds the kth smallest sum by counting qualifying subarrays for each candidate value. Time: O(n² log S), Space: O(1).

Common Approaches

✓ Stack

⏱️ Time: N/A Space: N/A

Binary Search on Answer

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

Use binary search to find the kth smallest sum by searching the answer space. For each candidate sum, count how many subarrays have sum ≤ candidate using sliding window technique. This avoids generating all sums explicitly.

Brute Force - Generate All Subarray Sums

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

Calculate the sum of every possible contiguous subarray, store all sums in a list, sort the list, and return the element at index k-1. This approach is straightforward but inefficient for large arrays.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int isConsecutive(char a, char b) {
    int diff = abs(a - b);
    return diff == 1 || (a == 'a' && b == 'z') || (a == 'z' && b == 'a');
}

char* solution(char* s) {
    int len = strlen(s);
    char* current = malloc((len + 1) * sizeof(char));
    char* prev = malloc((len + 1) * sizeof(char));
    strcpy(current, s);
    strcpy(prev, "");
    
    // Keep applying removals until no more changes
    while (strcmp(current, prev) != 0) {
        strcpy(prev, current);
        
        char* stack = malloc((len + 1) * sizeof(char));
        int top = -1;
        
        for (int i = 0; i < strlen(current); i++) {
            if (top >= 0 && isConsecutive(stack[top], current[i])) {
                top--;  // Remove the consecutive pair
            } else {
                stack[++top] = current[i];
            }
        }
        
        stack[top + 1] = '\0';
        strcpy(current, stack);
        free(stack);
    }
    
    free(prev);
    return current;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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