In algorithm design, you rarely get everything for free. One of the most fundamental trade-offs you'll encounter is:

Time vs. Space: You can often make an algorithm faster by using more memory, or use less memory by spending more time.

This isn't just an academic concept—it's a decision you'll face constantly:

• Should you precompute results and store them, or recompute on demand?
• Should you cache intermediate values, or recalculate them?
• Should you use a lookup table that takes megabytes, or a formula that takes milliseconds?

This page explores the conceptual foundations of time-space trade-offs, giving you the mental models to make these decisions wisely.

Imagine a spectrum with two extremes:

Left extreme: Minimize Space

• Store nothing extra
• Recompute everything on demand
• May be very slow
• Uses O(1) auxiliary space

Right extreme: Minimize Time

• Precompute and store everything
• Look up answers instantly
• Uses massive amounts of memory
• Queries are O(1)

Most practical algorithms live somewhere in between, strategically choosing what to store based on:

1. Frequency of access — Store what's accessed often
2. Cost of recomputation — Store what's expensive to recompute
3. Available resources — Store what fits in memory
4. Problem requirements — Store what the time limit demands

The Pattern:

Spend O(n) or O(n²) time upfront to build a structure that answers future queries in O(1) or O(log n).

When it helps:

• Many queries on the same data
• Query time matters more than setup time
• Data doesn't change (or changes rarely)

Classic Example: Prefix Sums

Problem: Given array A, answer Q queries "sum of A[l..r]"

Without precomputation:

• Each query: iterate l to r, sum elements
• Time: O(n) per query
• Space: O(1)
• Total for Q queries: O(Q × n) — too slow when both are 10⁵

With precomputation:

• Build prefix sum array P where P[i] = A[0] + A[1] + ... + A[i-1]
• Answer query: P[r+1] - P[l]
• Setup: O(n)
• Each query: O(1)
• Space: O(n)
• Total: O(n + Q) — fast!

The Space Cost:

Prefix sums use O(n) extra space—doubling memory usage for the array. Is it worth it?

Analysis:

• Without precomputation: 0 extra space, O(Q × n) time
• With precomputation: O(n) extra space, O(n + Q) time

If Q = 10⁵ and n = 10⁵:

• Without: 10¹⁰ operations (way too slow)
• With: 2 × 10⁵ operations (instant) + ~400 KB memory

The trade-off is overwhelmingly favorable. 400 KB is trivial; 10¹⁰ operations is impossible.

When precomputation doesn't help:

• Only 1 query: O(n) precompute + O(1) query = O(n), same as naive O(n)
• Data changes frequently: Must rebuild precomputation after each change
• Memory is severely constrained: Can't afford the extra storage

The Pattern:

When computing a function, store the result. If the same input appears again, return the stored result instead of recomputing.

When it helps:

• Same subproblems are solved multiple times (overlapping subproblems)
• Computation is expensive
• Inputs repeat

Classic Example: Recursive Fibonacci

Without memoization:

fib(n):
  if n <= 1: return n
  return fib(n-1) + fib(n-2)

• Time: O(2ⁿ) — exponential!
• Space: O(n) — recursion stack
• fib(40) makes ~2⁴⁰ ≈ 10¹² calls

With memoization:

memo = {}
fib(n):
  if n in memo: return memo[n]
  if n <= 1: result = n
  else: result = fib(n-1) + fib(n-2)
  memo[n] = result
  return result

• Time: O(n) — each subproblem computed once
• Space: O(n) — memo table + recursion stack
• fib(40) makes exactly 40 unique computations

The Space Cost:

Memoization stores results for each unique input:

• n unique inputs → O(n) space
• For 2D DP (e.g., n × m states) → O(n × m) space

When memoization is essential:

• Overlapping subproblems: Same computation repeated exponentially
• Without it: exponential time complexity
• With it: polynomial time complexity

When memoization is wasteful:

• No overlapping subproblems: Each state computed once anyway
• Linear recursion: Only one "path" through the problem
• Storage would exceed memory: Better to use space-optimized DP

Space-optimized alternative:

For problems like Fibonacci where you only need the last few results:

fib(n):
  if n <= 1: return n
  a, b = 0, 1
  for i in 2 to n:
    a, b = b, a + b
  return b

• Time: O(n)
• Space: O(1) — only store last two values!

This trades the flexibility of memoization for minimal space.

The Pattern:

For functions with bounded input domain, precompute all possible outputs and store in a table. Answer queries by direct lookup.

When it helps:

• Input domain is small and known
• Function is called many times
• Function is expensive to compute
• O(1) query time is critical

Example 1: Factorials modulo M

Problem: Answer Q queries for n! mod M, where n ≤ 10⁶.

Without lookup:

• Each query: compute n! = 1 × 2 × ... × n
• Time per query: O(n)
• Total: O(Q × n) — too slow if both are 10⁵

With lookup table:

fact = array of size n+1
fact[0] = 1
for i = 1 to n:
  fact[i] = fact[i-1] * i mod M

query(n): return fact[n]

• Setup: O(n)
• Query: O(1)
• Space: O(n)
• Total: O(n + Q) — fast!

Example 2: Population Count (Number of 1-bits)

Problem: Count the number of 1-bits in an integer, many times.

Without lookup:

• Count bits one by one: O(log n) per integer

With 8-bit lookup table:

bits = array of size 256
for i = 0 to 255:
  bits[i] = count_bits_naive(i)

popcount(x):
  return bits[x & 0xFF] + 
         bits[(x >> 8) & 0xFF] + 
         bits[(x >> 16) & 0xFF] + 
         bits[(x >> 24) & 0xFF]

• Setup: O(256) once
• Query: O(1) — just 4 lookups + additions
• Space: 256 bytes

This is how many real popcount implementations work!

Example 3: Precomputed Primes

Problem: Check if numbers are prime, many times, for numbers up to 10⁷.

Without lookup:

• Trial division: O(√n) per query

With Sieve of Eratosthenes:

is_prime = array of size n+1, all true
is_prime[0] = is_prime[1] = false
for i = 2 to sqrt(n):
  if is_prime[i]:
    for j = i*i to n step i:
      is_prime[j] = false

query(x): return is_prime[x]

• Setup: O(n log log n)
• Query: O(1)
• Space: O(n) bits — 10⁷ bits ≈ 1.25 MB

The trade-off calculation:

• Without sieve: Q × √n operations. For Q = 10⁵ and n = 10⁷: 10⁵ × 3162 ≈ 3 × 10⁸ operations
• With sieve: 2 × 10⁷ setup + 10⁵ queries ≈ 2 × 10⁷ operations + 1.25 MB

Sieve is 15x faster at the cost of 1.25 MB—almost always worth it.

The Pattern:

In dynamic programming, if you only need recent states to compute the next state, discard old states to save memory.

When it helps:

• Full DP table would exceed memory limit
• Each state only depends on a fixed number of previous states
• You don't need to reconstruct the full solution path

Example: Longest Common Subsequence

Problem: Find LCS length of strings A (length n) and B (length m).

Standard DP:

• dp[i][j] = LCS of A[0..i-1] and B[0..j-1]
• dp[i][j] = dp[i-1][j-1] + 1 if A[i-1] == B[j-1]
• dp[i][j] = max(dp[i-1][j], dp[i][j-1]) otherwise
• Space: O(n × m) — for n = m = 10,000, that's 400 MB!

Space-optimized DP:

Observation: dp[i][...] only depends on dp[i-1][...]. We don't need rows before i-1!

prev = array of size m+1, all 0
curr = array of size m+1, all 0

for i = 1 to n:
  for j = 1 to m:
    if A[i-1] == B[j-1]:
      curr[j] = prev[j-1] + 1
    else:
      curr[j] = max(prev[j], curr[j-1])
  swap(prev, curr)

return prev[m]

• Space: O(m) — just 2 rows!
• For n = m = 10,000: only 80 KB instead of 400 MB

The trade-off:

• Same time complexity: O(n × m)
• 5000x less space
• Trade-off: Can't reconstruct the actual LCS, only the length

If you need the actual subsequence, you'd have to store more or use other techniques (or accept the O(n × m) space).

Example: Fibonacci (revisited)

Full memoization: O(n) space for memo table Space-optimized: O(1) space with just a, b variables

Example: 0/1 Knapsack

Full DP: dp[i][w] for i items and w weight → O(n × W) space Space-optimized: Only need previous row → O(W) space (But must iterate W in reverse to avoid using updated values)

When to use full DP vs. space-optimized:

When facing a time-space trade-off, use this decision framework:

Step 1: Check if the trade-off is necessary

Does the naive approach violate constraints?

• Naive approach times out? → Consider using more space to speed up
• Naive approach exceeds memory? → Consider trading time for space
• Both fit constraints? → Use the simpler approach

Step 2: Calculate the resource requirements

For time:

• How many operations does each approach take?
• Which fits within the time limit?

For space:

• How much memory does each approach use?
• Which fits within the memory limit?

Step 3: Consider secondary factors

If both approaches meet constraints:

Favor simplicity:

• Simpler code = fewer bugs
• Easier to understand and maintain
• Faster to implement in a contest

Favor headroom:

• If one approach uses 80% of budget and another uses 20%, prefer 20%
• Leaves room for constant factors, edge cases

Favor flexibility:

• If you might need to extend the solution, prefer the approach that's easier to modify

Step 4: In production, consider additional factors

• Write speed: Is data written once, read many times? Optimize for reads.
• Cache locality: Sequential memory access is faster than random.
• Parallelization: Some trade-offs parallelize better.
• Cost: Cloud memory and compute have different price points.

Here are trade-offs you'll encounter repeatedly:

Scenario 1: In-place vs. Auxiliary Space

In-place (modify input):

• Sorting: Quicksort, heapsort use O(log n) stack space
• Reversal: Swap elements directly
• Pro: Minimal memory
• Con: Destroys original data

With auxiliary space:

• Sorting: Merge sort uses O(n) extra
• Reversal: Create new array
• Pro: Original preserved
• Con: Uses more memory

Decision: Use in-place when memory is tight and you don't need the original. Use auxiliary when you need to preserve input or in-place would be too complex.

Scenario 2: Iterative vs. Recursive

Recursive:

• Elegant, matches problem structure
• Uses O(depth) stack space for call frames
• Risk of stack overflow for deep recursion

Iterative with explicit stack:

• Same logic, but uses heap-allocated stack
• Avoids stack overflow
• Slightly more complex code

Tail-recursive optimized:

• Compiler converts to iteration
• Only works for specific patterns

Decision: Use recursion for clarity when depth is bounded. Convert to iteration with explicit stack when depth might be large (e.g., traversing deep trees).

Scenario 3: Hash Table vs. Sorting

Hash table approach:

• O(n) time, O(n) space
• Handles lookups and existence checks

Sorting approach:

• O(n log n) time, O(1) to O(n) space depending on algorithm
• Enables binary search, two pointers

Decision: Hash table when you need O(1) lookups and have memory. Sorting when space is tight or you need ordered traversal.

Scenario 4: Store All vs. Streaming

Store all:

• Read entire input into memory
• Process with random access
• Works: Multiple passes, any order

Streaming (online):

• Process each element as it arrives
• O(1) or O(log n) memory
• Can't look back at previous elements

Decision: Stream when memory is critical or data is infinite. Store when you need multiple passes or random access.

Scenario 5: Eager vs. Lazy Computation

Eager:

• Compute everything upfront
• Higher initial cost, fast subsequent access

Lazy:

• Compute only when needed
• Lower initial cost, computing on demand
• May recompute same thing multiple times

Decision: Eager when most values will be accessed. Lazy when only some values are needed (or you want to defer work).

Time-space trade-offs are omnipresent in algorithm design. Understanding them lets you make informed decisions rather than blindly picking the first approach that comes to mind.

What's next:

We've discussed trading time for space and vice versa. But there's another kind of trade-off: sometimes a "slower" algorithm is actually the right choice. The next page explores when simplicity, correctness, or maintainability outweighs raw speed.