Maximum Subarray in Python

The Maximum Subarray Problem involves finding a contiguous subarray within an array that has the largest sum. This is a classic problem that can be efficiently solved using Kadane's Algorithm, which uses dynamic programming principles.

For example, given the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the maximum subarray is [4, -1, 2, 1] with sum 6.

Algorithm Overview

The dynamic programming approach works as follows ?

• Create a DP array of the same size as input array
• Initialize dp[0] = nums[0]
• For each position i, calculate: dp[i] = max(dp[i-1] + nums[i], nums[i])
• Return the maximum value in the DP array

Dynamic Programming Solution

Here's the implementation using the DP approach ?

def max_subarray_dp(nums):
    """
    Find maximum subarray sum using dynamic programming
    """
    if not nums:
        return 0
    
    dp = [0] * len(nums)
    dp[0] = nums[0]
    
    for i in range(1, len(nums)):
        dp[i] = max(dp[i-1] + nums[i], nums[i])
    
    return max(dp)

# Test with examples
nums1 = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print(f"Array: {nums1}")
print(f"Maximum subarray sum: {max_subarray_dp(nums1)}")

nums2 = [-2, 1, -3, 7, -2, 2, 1, -5, 4]
print(f"Array: {nums2}")
print(f"Maximum subarray sum: {max_subarray_dp(nums2)}")

Array: [-2, 1, -3, 4, -1, 2, 1, -5, 4]
Maximum subarray sum: 6
Array: [-2, 1, -3, 7, -2, 2, 1, -5, 4]
Maximum subarray sum: 8

Optimized Kadane's Algorithm

We can optimize the space complexity to O(1) by using just two variables ?

def kadane_algorithm(nums):
    """
    Kadane's Algorithm - optimized space complexity
    """
    if not nums:
        return 0
    
    max_ending_here = nums[0]
    max_so_far = nums[0]
    
    for i in range(1, len(nums)):
        max_ending_here = max(nums[i], max_ending_here + nums[i])
        max_so_far = max(max_so_far, max_ending_here)
    
    return max_so_far

# Test the optimized version
nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
result = kadane_algorithm(nums)
print(f"Maximum subarray sum: {result}")

Maximum subarray sum: 6

Finding the Actual Subarray

To return both the sum and the actual subarray elements ?

def max_subarray_with_indices(nums):
    """
    Returns maximum sum and the actual subarray
    """
    if not nums:
        return 0, []
    
    max_sum = nums[0]
    current_sum = nums[0]
    start = end = 0
    temp_start = 0
    
    for i in range(1, len(nums)):
        if current_sum < 0:
            current_sum = nums[i]
            temp_start = i
        else:
            current_sum += nums[i]
        
        if current_sum > max_sum:
            max_sum = current_sum
            start = temp_start
            end = i
    
    return max_sum, nums[start:end+1]

# Find both sum and subarray
nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
max_sum, subarray = max_subarray_with_indices(nums)
print(f"Maximum sum: {max_sum}")
print(f"Subarray: {subarray}")

Maximum sum: 6
Subarray: [4, -1, 2, 1]

Comparison

Conclusion

Kadane's Algorithm efficiently solves the maximum subarray problem in linear time. Use the DP approach for understanding, but prefer the optimized O(1) space version for production code.