Divide and Conquer — Integer Overflow at 2^30 Elements

Divide and conquer is the algorithmic pattern behind merge sort, binary search, fast Fourier transform, Strassen's matrix multiplication, and closest pair of points. If you understand D&C deeply, you understand why all of these algorithms work and how to design new ones.

The pattern is deceptively simple: split the problem, solve each half, combine. The complexity depends almost entirely on the combine step — and the Master Theorem gives you an algebraic shortcut to avoid solving the recurrence from scratch each time. Learning the Master Theorem once saves you dozens of recurrence derivations throughout your career.

The Three-Step Pattern

Every divide and conquer algorithm follows the same template:

1. Divide: Split the problem into subproblems (usually of equal or near-equal size)
2. Conquer: Solve each subproblem recursively (base case when small enough)
3. Combine: Merge subproblem solutions into the overall solution

The efficiency depends critically on the combine step. Merge sort's O(n log n) comes from an O(n) combine. Binary search has O(1) combine (no merging needed).

That's it. If you can describe your algorithm as: split, solve halves, merge results — you've got a divide and conquer. The rest is just details about how fast that merge is.

def divide_and_conquer(problem):
    # Base case
    if is_small_enough(problem):
        return solve_directly(problem)
    # Divide
    subproblems = divide(problem)
    # Conquer
    solutions = [divide_and_conquer(sub) for sub in subproblems]
    # Combine
    return combine(solutions)

The Master Theorem

For recurrences of the form T(n) = aT(n/b) + f(n) where a ≥ 1, b > 1:

• Case 1: f(n) = O(n^(log_b(a) - ε)) → T(n) = Θ(n^log_b(a))
• Case 2: f(n) = Θ(n^log_b(a)) → T(n) = Θ(n^log_b(a) · log n)
• Case 3: f(n) = Ω(n^(log_b(a) + ε)) → T(n) = Θ(f(n))

Examples: - Merge sort: T(n) = 2T(n/2) + O(n) → Case 2 → O(n log n) - Binary search: T(n) = T(n/2) + O(1) → Case 2 → O(log n) - Strassen: T(n) = 7T(n/2) + O(n²) → Case 1 → O(n^2.807) - Simple recursion: T(n) = 2T(n/2) + O(1) → Case 1 → O(n)

Canonical Examples

These three algorithms are the classic divide and conquer triad — they show how the same pattern yields wildly different complexities depending on the combine step.

Binary Search: Divide the search space in half, conquer by checking the mid, combine is O(1) (just return mid or recurse). Result: O(log n).

Merge Sort: Divide at midpoint, conquer recursively, combine by merging two sorted halves in O(n) time. Result: O(n log n).

Fast Power: Divide exponent by 2, conquer by squaring the half-result, combine is O(1) multiplication. Result: O(log n) versus naive O(n).

The key insight: the combine step is the only thing that changes between these three. The divide and conquer skeleton stays the same.

# Binary Search — O(log n)
def binary_search(arr, target, lo, hi):
    if lo > hi: return -1
    mid = (lo + hi) // 2
    if arr[mid] == target: return mid
    if arr[mid] < target: return binary_search(arr, target, mid+1, hi)
    return binary_search(arr, target, lo, mid-1)

# Merge Sort — O(n log n)
def merge_sort(arr):
    if len(arr) <= 1: return arr
    mid = len(arr) // 2
    left  = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result, i, j = [], 0, 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]: result.append(left[i]); i += 1
        else:                   result.append(right[j]); j += 1
    return result + left[i:] + right[j:]

# Power function — O(log n)
def fast_power(base, exp):
    if exp == 0: return 1
    if exp % 2 == 0:
        half = fast_power(base, exp // 2)
        return half * half
    return base * fast_power(base, exp - 1)

print(fast_power(2, 10))  # 1024

When Divide and Conquer Pays Off

D&C pays off when: 1. Subproblems are independent (no shared state to communicate) 2. Subproblems are of equal or balanced size (imbalanced splits degrade to O(n²)) 3. The combine step is efficient (O(n) or less)

Master Theorem Extended: When the Basic Cases Don't Apply

Not all recurrences fit the clean form T(n) = aT(n/b) + f(n). Real-world D&C algorithms often break the assumptions:

1. Non-constant a or b: The number of subproblems or the split factor may vary per recursion level. Example: quick sort's pivot selection leads to varying b.
2. Floating-point splits: Algorithms like Strassen's matrix multiplication split matrices into halves, but for odd dimensions you need padding — this breaks the clean n/b assumption.
3. F(n) is non-polynomial: If combine is something like n log n (O(n log n)), Master Theorem's polynomial comparison fails. You need the extended case 2 with a log factor.

Akra-Bazzi Theorem handles variable subproblem sizes. For recurrences of the form T(n) = Σ a_i T(b_i n) + f(n), compute p such that Σ a_i (b_i)^p = 1. Then T(n) = Θ(n^p + n^p ∫ f(u)/u^(p+1) du).

This is rarely needed in interviews, but if you work on custom D&C algorithms (e.g., in numerical computing), it's essential.