Memoization to Optimize Recursion in DSA Python - Time & Space Complexity

Time Complexity: Memoization to Optimize Recursion

O(n)

Understanding Time Complexity

When we use recursion, some calculations repeat many times. Memoization helps by remembering results to avoid repeating work.

We want to know how this remembering changes the time it takes to run the code.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

def fib_memo(n, memo=None):
    if memo is None:
        memo = {}
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fib_memo(n-1, memo) + fib_memo(n-2, memo)
    return memo[n]

This code calculates the nth Fibonacci number using recursion with memoization to store results.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Recursive calls to fib_memo for smaller numbers.
• How many times: Each unique number from 0 to n is computed once and stored.

How Execution Grows With Input

Each number up to n is calculated once, so the work grows steadily as n grows.

Input Size (n)	Approx. Operations
10	About 10 calculations
100	About 100 calculations
1000	About 1000 calculations

Pattern observation: The number of operations grows roughly in a straight line with n.

Final Time Complexity

Time Complexity: O(n)

This means the time to finish grows directly with the input size because each result is calculated once and reused.

Common Mistake

[X] Wrong: "Memoization does not change the time complexity of recursion."

[OK] Correct: Without memoization, many calls repeat work, causing exponential time. Memoization stores results, reducing repeated work and lowering time complexity to linear.

Interview Connect

Understanding how memoization improves recursion shows you can make slow solutions fast by smartly remembering work done. This skill is valuable for solving many problems efficiently.

Self-Check

"What if we removed memoization and used plain recursion? How would the time complexity change?"

Practice

1. What is the main purpose of using memoization in recursive functions?

easy

A. To replace recursion with iteration

B. To make the function run slower by adding extra steps

C. To store results of expensive function calls and reuse them

D. To increase the memory usage without any benefit

Solution

1. Step 1: Understand what memoization does

   Memoization saves the results of function calls so that if the same inputs occur again, the function can return the saved result instead of recalculating.

2. Step 2: Identify the benefit of memoization

   This saves time by avoiding repeated calculations, making recursive functions faster.

3. Final Answer:

   To store results of expensive function calls and reuse them -> Option C

4. Quick Check:

   Memoization = Store and reuse results [OK]

Hint: Memoization saves repeated work by caching results [OK]

Common Mistakes:

• Thinking memoization slows down the function
• Confusing memoization with converting recursion to loops
• Believing memoization always increases memory without benefit

2. Which of the following is the correct way to define a memo dictionary inside a recursive function in Python?

easy

A. def fib(n, memo={}):

B. def fib(n, memo=None): memo = {}

C. def fib(n, memo=[]):

D. def fib(n, memo=0):

Solution

1. Step 1: Understand default mutable arguments problem

   Using a mutable default argument like a dictionary directly can cause unexpected behavior because the same dictionary is shared across calls.

2. Step 2: Use None as default and initialize inside

   Setting memo=None and then initializing memo = {} inside the function avoids this problem and is the correct pattern.

3. Final Answer:

   def fib(n, memo=None): memo = {} -> Option B

4. Quick Check:

   Use None default and initialize dict inside [OK]

Hint: Use None default and create dict inside function [OK]

Common Mistakes:

• Using mutable default arguments directly
• Using list instead of dictionary for memo
• Setting memo default to 0 which is invalid

3. What will be the output of the following code?

def fib(n, memo=None):
    if memo is None:
        memo = {}
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fib(n-1, memo) + fib(n-2, memo)
    return memo[n]

print(fib(5))

medium

A. 8

B. None

C. 3

D. 5

Solution

1. Step 1: Trace fib(5) with memoization

   fib(5) = fib(4) + fib(3), fib(4) = fib(3) + fib(2), and so on. Using memoization avoids repeated calls.

2. Step 2: Calculate fib(5)

   fib(0)=0, fib(1)=1, fib(2)=1, fib(3)=2, fib(4)=3, fib(5)=5.

3. Final Answer:

   5 -> Option D

4. Quick Check:

   fib(5) = 5 [OK]

Hint: Remember fib(5) = 5 in Fibonacci sequence [OK]

Common Mistakes:

• Confusing fib(5) with fib(6)
• Ignoring memo and recalculating values
• Returning None due to missing return

4. Identify the error in this memoized factorial function and select the fix:

def factorial(n, memo=None):
    if memo is None:
        memo = {}
    if n == 0:
        return 1
    if n in memo:
        return memo[n]
    memo[n] = n * factorial(n-1)
    return memo[n]

medium

A. Add memo argument in recursive call: factorial(n-1, memo)

B. Change base case to n == 1

C. Initialize memo as a list instead of dict

D. Remove memo dictionary completely

Solution

1. Step 1: Check recursive call parameters

   The recursive call factorial(n-1) misses passing memo, so memo is reset each time, losing stored results.

2. Step 2: Fix by passing memo in recursive call

   Change to factorial(n-1, memo) to keep using the same memo dictionary.

3. Final Answer:

   Add memo argument in recursive call: factorial(n-1, memo) -> Option A

4. Quick Check:

   Pass memo in recursion to keep cache [OK]

Hint: Always pass memo in recursive calls [OK]

Common Mistakes:

• Forgetting to pass memo in recursive call
• Changing base case unnecessarily
• Using list instead of dictionary for memo

5. You want to optimize a recursive function that calculates the number of ways to climb n stairs, taking 1 or 2 steps at a time. Which memoization approach below correctly avoids redundant calculations and handles edge cases?

hard

A. Use memo=None default, initialize inside, pass memo in recursive calls, and handle base cases for n=0 and n=1

B. Use a default mutable argument dictionary and update it inside the function

C. Do not use memoization; rely on simple recursion for clarity

D. Use a global dictionary outside the function to store results and pass n only

Solution

1. Step 1: Understand memoization best practice

   Using memo=None default and initializing inside avoids shared mutable defaults and ensures fresh memo per call.

2. Step 2: Pass memo in recursive calls and handle base cases

   Passing memo keeps cache consistent. Base cases n=0 (1 way) and n=1 (1 way) prevent infinite recursion and define correct results.

3. Final Answer:

   Use memo=None default, initialize inside, pass memo in recursion, handle base cases -> Option A

4. Quick Check:

   Proper memo init and passing + base cases = correct [OK]

Hint: Initialize memo inside and pass it in recursion [OK]

Common Mistakes:

• Using global variables causing side effects
• Using mutable default arguments directly
• Ignoring base cases causing infinite recursion