Sum of the [maximums of all subarrays multiplied by their lengths], in linear time

ONLINECAST

2 min read

·

05-10-2024

6

0

Share

Calculating the Sum of Maximums in Subarrays: A Linear Time Approach

Problem: Given an array of integers, we need to find the sum of the maximum values of all possible subarrays, multiplied by the length of those subarrays. For example, given the array [1, 2, 3, 4, 5], we need to calculate the sum of the maximum values of all subarrays ([1], [1, 2], [1, 2, 3], ... , [5]) multiplied by their respective lengths.

Rephrased: Imagine you have a list of numbers, and you want to find the sum of the largest numbers in all possible smaller lists within the original list, multiplied by the size of those smaller lists.

Example and Code:

Let's consider the array [1, 2, 3, 4, 5].

def naive_max_sum(arr):
    """
    Calculates the sum of the maximum values of all subarrays multiplied by their lengths using a brute-force approach.
    """
    n = len(arr)
    total_sum = 0
    for i in range(n):
        for j in range(i, n):
            subarray = arr[i:j+1]
            total_sum += max(subarray) * len(subarray)
    return total_sum

arr = [1, 2, 3, 4, 5]
result = naive_max_sum(arr)
print(f"Sum of maximums multiplied by length: {result}")

This naive approach iterates through all possible subarrays, calculates the maximum, and multiplies it by the subarray's length. While it works, its time complexity is O(n^3) as it iterates through nested loops.

Linear Time Solution:

We can achieve a linear time solution by utilizing the fact that the maximum of a subarray is either the current element or the maximum of the previous subarray. This allows us to maintain the running maximum and calculate the sum in a single pass through the array.

def linear_max_sum(arr):
    """
    Calculates the sum of the maximum values of all subarrays multiplied by their lengths in linear time.
    """
    n = len(arr)
    total_sum = 0
    max_so_far = arr[0]
    for i in range(n):
        max_so_far = max(max_so_far, arr[i])
        total_sum += max_so_far * (i + 1)
    return total_sum

arr = [1, 2, 3, 4, 5]
result = linear_max_sum(arr)
print(f"Sum of maximums multiplied by length: {result}") 

Explanation:

1. We initialize max_so_far with the first element of the array.
2. For each element arr[i], we update max_so_far to be the maximum between its current value and the current element.
3. The maximum element encountered so far is multiplied by the current length (i + 1) to get the contribution of the maximum value for all subarrays ending at index i. This contribution is then added to the total_sum.

Benefits of Linear Time Solution:

• Efficiency: The linear time solution significantly improves performance compared to the brute-force approach, especially for larger arrays.
• Simplicity: The code is concise and easy to understand.

Conclusion:

By leveraging the relationship between the maximums of consecutive subarrays, we can calculate the sum of maximums multiplied by lengths in linear time. This efficient solution offers a significant improvement in performance over the brute-force approach.