from typing import List, Tuple

# 1. Brute Force O(N^2)
def solve_brute_force(arr: List[int]) -> int:
    max_sum = float('-inf')
    n = len(arr)
    for i in range(n):
        current_sum = 0
        for j in range(i, n):
            current_sum += arr[j]
            if current_sum > max_sum:
                max_sum = current_sum
    return max_sum

# 2. Divide and Conquer O(N log N)
def solve_divide_conquer(arr: List[int]) -> int:
    def max_crossing_sum(arr, low, mid, high):
        left_sum = float('-inf')
        curr_sum = 0
        for i in range(mid, low - 1, -1):
            curr_sum += arr[i]
            if curr_sum > left_sum:
                left_sum = curr_sum
        
        right_sum = float('-inf')
        curr_sum = 0
        for i in range(mid + 1, high + 1):
            curr_sum += arr[i]
            if curr_sum > right_sum:
                right_sum = curr_sum
        
        return left_sum + right_sum

    def solve_recursive(arr, low, high):
        if low == high:
            return arr[low]
        
        mid = (low + high) // 2
        
        return max(
            solve_recursive(arr, low, mid),
            solve_recursive(arr, mid + 1, high),
            max_crossing_sum(arr, low, mid, high)
        )

    if not arr:
        return 0
    return solve_recursive(arr, 0, len(arr) - 1)

# 3. Dynamic Programming (Kadane's Algorithm) O(N)
def solve_kadane(arr: List[int]) -> int:
    if not arr:
        return 0
    max_so_far = arr[0]
    curr_max = arr[0]
    
    for i in range(1, len(arr)):
        curr_max = max(arr[i], curr_max + arr[i])
        max_so_far = max(max_so_far, curr_max)
        
    return max_so_far