LeetCode Solutions Blog

Maximum and Minimum Sums of at Most Size K Subarrays

Difficulty: Hard

Problem Description

You are given an integer array nums and a positive integer k. Return the sum of the maximum and minimum elements of all non-empty subarrays with at most k elements.

Key Insights

The problem involves calculating sums from subarrays of varying lengths (up to k).
Each subarray contributes its minimum and maximum values to the final sum.
Efficiently finding the min and max values can be achieved using a monotonic stack approach.
The naive approach of generating all subarrays and calculating their min and max would be too slow for larger inputs.

Space and Time Complexity

Time Complexity: O(n)
Space Complexity: O(k)

Solution

To solve the problem, we will use two monotonic stacks: one for tracking the minimum values and another for the maximum values in the current window of size up to k. The idea is to iterate through the array and maintain these stacks to keep track of potential minimum and maximum values efficiently. When we add a new element, we pop elements from the stack that are not valid for the current subarray size. The sum of the maximum and minimum for each subarray will be calculated and accumulated to get the final result.

Code Solutions

def max_min_sums(nums, k):
    n = len(nums)
    total_sum = 0

    # Monotonic stacks for minimum and maximum
    min_stack = []
    max_stack = []

    for i in range(n):
        # Maintain the min stack
        while min_stack and nums[min_stack[-1]] >= nums[i]:
            min_stack.pop()
        min_stack.append(i)

        # Maintain the max stack
        while max_stack and nums[max_stack[-1]] <= nums[i]:
            max_stack.pop()
        max_stack.append(i)

        # Calculate the contribution of subarrays ending at i
        # For minimum
        while min_stack and min_stack[0] <= i:
            j = min_stack.pop(0)
            total_sum += nums[j]
        
        # For maximum
        while max_stack and max_stack[0] <= i:
            j = max_stack.pop(0)
            total_sum += nums[j]

        # Pop invalid indices that are out of the current window size
        if i >= k:
            if min_stack and min_stack[0] <= i - k:
                min_stack.pop(0)
            if max_stack and max_stack[0] <= i - k:
                max_stack.pop(0)

    return total_sum

# Example usage
print(max_min_sums([1, 2, 3], 2))  # Output: 20
print(max_min_sums([1, -3, 1], 2))  # Output: -6