62 lines
1.6 KiB
Python
62 lines
1.6 KiB
Python
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
|