Maximum Good Subarray Sum - Practice Coding Problems

Maximum Good Subarray Sum - Problem

You are given an array nums of length n and a positive integer k. Your task is to find the maximum sum among all "good" subarrays.

A subarray nums[i..j] is considered good if the absolute difference between its first and last element is exactly k. In other words: |nums[i] - nums[j]| == k

Goal: Return the maximum sum of a good subarray. If no good subarrays exist, return 0.

Example: For nums = [1, 2, 3, 4, 5] and k = 3, the subarray [1, 2, 3, 4] is good because |1 - 4| = 3, and its sum is 10.

Input & Output

example_1.py — Basic Case

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

› Output: 11

💡 Note: The subarray [5,6] is good because |5-6| = 1 = k, and has sum 11. Other good subarrays like [1,2] have smaller sums.

example_2.py — Multiple Good Subarrays

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

› Output: 11

💡 Note: The subarray [2,4,5] is good because |2-5| = 3 = k, and has sum 11. The subarray [-1,3,2] is also good since |-1-2| = 3, but has sum 4.

example_3.py — No Good Subarrays

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

› Output: 0

💡 Note: No pair of elements has absolute difference of 10, so there are no good subarrays. Return 0.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Track Prefix Sums

Maintain running sum and map each value to minimum prefix sum seen

Look for Complements

For each element x, check if x±k exists in our map

Calculate Instantly

Use prefix sum difference to get subarray sum in O(1)

Key Takeaway

🎯 Key Insight: Prefix sums with hash maps transform the problem from checking all pairs O(n²) to single-pass complement lookup O(n)

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses prefix sums with hash tables to solve this in O(n) time. Key insight: for each element, check if we've seen values that are exactly k units away, then use prefix sum differences to calculate subarray sums instantly. This avoids the O(n³) nested loops of brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check all possible subarrays and find those where \|first - last\| == k
One-Pass Hash Table with Prefix Sums (Optimal)	O(n)	O(n)	Use prefix sums and hash map to find good subarrays in single pass

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all possible starting positions i
For each i, iterate through all ending positions j > i
Check if |nums[i] - nums[j]| == k
If condition met, calculate subarray sum from i to j
Keep track of maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with i=0

Check all j > 0 to see if |nums[0] - nums[j]| == k

Move to i=1

Check all j > 1 to see if |nums[1] - nums[j]| == k

Continue pattern

Repeat for all starting positions

Code -

solution.c — C

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

long long maximumSubarraySum(int* nums, int n, int k) {
    long long maxSum = LLONG_MIN;
    int found = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (abs(nums[i] - nums[j]) == k) {
                long long currentSum = 0;
                for (int x = i; x <= j; x++) {
                    currentSum += nums[x];
                }
                if (currentSum > maxSum) {
                    maxSum = currentSum;
                }
                found = 1;
            }
        }
    }
    
    return found ? maxSum : 0;
}

int main() {
    int nums[] = {1, 2, 3, 4, 5, 6};
    int n = 6;
    int k = 1;
    printf("%lld\n", maximumSubarraySum(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Two nested loops O(n²) and sum calculation O(n) for each valid subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum sum and indices

✓ Linear Space

78.2K Views

High Frequency

~18 min Avg. Time

1.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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler