5 Best Ways to Find Maximum Sum of Two Non-Overlapping Sublists in Python

Rate this post

πŸ’‘ Problem Formulation: The task is to determine the maximum sum achievable from two non-overlapping sublists within a single list of integers. For example, given the list [1, 0, 3, 4, 2, 5] and sublist lengths of l1=1 and l2=2, the desired output is 9, which comes from sublists [4] and [2, 5], yielding the maximum sum without overlap.

Method 1: Brute Force Approach

This method iterates over all possible pairs of non-overlapping sublists, calculates their sums, and keeps track of the maximum. It’s a straightforward approach but not efficient for large lists, having a time complexity of O(n^3), where n is the list size.

Here’s an example:

def max_sum_two_sublists(arr, l1, l2):
    n = len(arr)
    max_sum = 0
    for i in range(n - l1 + 1):
        for j in range(i + l1, n - l2 + 1):
            first = sum(arr[i:i+l1])
            second = sum(arr[j:j+l2])
            max_sum = max(max_sum, first + second)
    return max_sum

arr = [1, 2, 3, 0, 6]
print(max_sum_two_sublists(arr, 1, 2))



The function max_sum_two_sublists() takes an array and the lengths of the two sublists as arguments. It checks all possible pairs of sublists in the array and updates the maximum sum found. While this method is easy to understand and implement, it’s not the most time-efficient for large datasets.

Method 2: Dynamic Programming

The dynamic programming method improves efficiency by storing the maximum sum of sublists up to each index, reducing the need for recalculating sums. Its time complexity is O(n), making it suitable for larger datasets.

Here’s an example:

def maxSumTwoNoOverlap(A, L, M):
    for i in range(1, len(A)):
        A[i] += A[i - 1]
    res, Lmax, Mmax = A[L + M - 1], A[L - 1], A[M - 1]
    for i in range(L + M, len(A)):
        Lmax = max(Lmax, A[i - M] - A[i - L - M])
        Mmax = max(Mmax, A[i - L] - A[i - L - M])
        res = max(res, Lmax + A[i] - A[i - M], Mmax + A[i] - A[i - L])
    return res

arr = [1, 2, 3, 0, 6]
print(maxSumTwoNoOverlap(arr, 1, 2))



The maxSumTwoNoOverlap() function first calculates cumulative sums. Then, it initializes the result and max sums for the two sublist sizes. It iterates once over the list to calculate non-overlapping sublists’ max sum. This method is significantly faster for larger inputs due to its linear complexity.

Method 3: Sliding Window

This method uses a sliding window to keep a running sum of sublists, drastically reducing the number of operations compared to the brute force approach. It moves the window across the list to find the maximum sum of a sublist, then repeats for the second sublist.

Here’s an example:

def maxSumTwoSublists(arr, l1, l2):
    def maxSumForLength(arr, l):
        max_sum, curr_sum = 0, sum(arr[:l])
        for i in range(l, len(arr)):
            curr_sum += arr[i] - arr[i - l]
            max_sum = max(max_sum, curr_sum)
        return max_sum

    max_l1_before = [0] * len(arr)
    max_l2_after = [0] * len(arr)

    curr_sum = sum(arr[:l1])
    for i in range(l1, len(arr)):
        max_l1_before[i] = max(max_l1_before[i - 1], curr_sum)
        curr_sum += arr[i] - arr[i - l1]

    curr_sum = sum(arr[-l2:])
    for i in range(len(arr) - l2 - 1, -1, -1):
        max_l2_after[i] = max(max_l2_after[i + 1], curr_sum)
        curr_sum += arr[i] - arr[i + l2]

    max_sum = max(max_l1_before[i] + max_l2_after[i + 1] for i in range(l1 - 1, len(arr) - l2 - 1))
    return max_sum

arr = [1, 2, 3, 0, 6]
print(maxSumTwoSublists(arr, 1, 2))



The maxSumTwoSublists() function uses two main loops to calculate the maximum sum of the first sublist before the current index and the second sublist after the current index. Then, it combines these in a final loop to find the maximum sum of two non-overlapping sublists. This approach is more efficient than brute force but less so than dynamic programming.

Method 4: Prefix and Suffix Maximum Arrays

By constructing prefix and suffix arrays to store the maximum sum of sublists up to and from each index respectively, this method allows for efficient querying of the sums required to calculate the result. This approach often accompanies dynamic programming or sliding window optimizations.

Here’s an example:

def maxSumTwoSublists(arr, l1, l2):
    ... # Similar setup and implementation as the Sliding Window method
    ... # Utilizes prefix and suffix maximums for achieving the result
    ... # Code would be essentially similar to Sliding Window example
    return max_sum

In practice, this method and the sliding window approach can look quite similar, and the distinction might be more conceptual than practical. The main idea is to avoid re-computation and swiftly access pre-calculated sums.

Bonus One-Liner Method 5: Itertools and Built-in Functions

A one-liner solution can be constructed using Python’s itertools to generate all possible pairs of non-overlapping sublists, and the built-in max function to find the maximum sum.

Here’s an example:

from itertools import combinations
arr = [1, 2, 3, 0, 6]
l1, l2 = 1, 2
print(max(sum(arr[i:i+l1]) + sum(arr[j:j+l2])
          for i, j in combinations(range(len(arr) - l2 + 1), 2)
          if j >= i + l1))



This one-liner leverages the power of Python’s list comprehensions and itertools to generate index pairs, check for non-overlap, and calculate sums in a highly compact form. While this offers succinct code, it sacrifices readability and performance on larger datasets as it ultimately executes a brute force algorithm.


  • Method 1: Brute Force Approach. Simple and easy to understand. Very slow on large datasets.
  • Method 2: Dynamic Programming. Highly efficient. Requires more complex logic and may be harder to understand for beginners.
  • Method 3: Sliding Window. More efficient than brute force while still maintaining readability. Not as optimal as dynamic programming for all use cases.
  • Method 4: Prefix and Suffix Maximum Arrays. Offers a good balance between efficiency and readability. Similar pros and cons as the sliding window method.
  • Bonus Method 5: Itertools and Built-in Functions. Offers a succinct, although less efficient, solution. Good for small datasets or where code brevity is a priority.