Fibonacci Using DP in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind using Dynamic Programming (DP) to calculate Fibonacci numbers?

DP stores the results of smaller subproblems (previous Fibonacci numbers) to avoid repeated calculations, making the process faster and more efficient.

beginner

What is the time complexity of calculating Fibonacci numbers using DP?

The time complexity is O(n) because each Fibonacci number up to n is calculated once and stored for reuse.

intermediate

Explain the difference between top-down and bottom-up approaches in DP for Fibonacci.

Top-down uses recursion with memoization to store results as needed. Bottom-up builds the solution iteratively from the smallest subproblems up to the desired number.

beginner

Why is memoization important in the top-down DP approach for Fibonacci?

Memoization saves previously computed Fibonacci values so the function does not recompute them, reducing exponential time to linear time.

beginner

What data structure is commonly used to store intermediate Fibonacci results in DP?

A list or array is commonly used to store intermediate Fibonacci numbers for quick access and update.

What does DP stand for in the context of Fibonacci calculation?

A Data Parsing

B Direct Processing

C Dynamic Programming

D Distributed Processing

DP stands for Dynamic Programming, a method to solve problems by breaking them down into simpler subproblems and storing their results.

Which of these is NOT a benefit of using DP for Fibonacci?

A Uses recursion without storing results

B Avoids repeated calculations

C Improves time complexity to O(n)

D Stores intermediate results

Using recursion without storing results leads to repeated calculations and exponential time, which DP avoids.

In bottom-up DP for Fibonacci, what is the first step?

A Initialize base cases like Fibonacci(0) and Fibonacci(1)

B Use recursion to calculate Fibonacci(n-1)

C Calculate Fibonacci(n) directly

D Store Fibonacci(n) in a dictionary

Bottom-up DP starts by initializing base cases, then builds up to the desired Fibonacci number.

What is memoization?

A A sorting algorithm

B A type of loop

C A way to delete unused data

D Storing results of subproblems to avoid recomputation

Memoization is storing results of subproblems so they can be reused, improving efficiency.

Which data structure is best for storing Fibonacci numbers in DP?

A Stack

B Array or list

C Tree

D Queue

An array or list allows quick access and update of Fibonacci numbers by index.

Describe how you would use dynamic programming to calculate the 10th Fibonacci number.

Think about building the solution step by step from the smallest numbers.

Explain the difference between memoization and tabulation in dynamic programming for Fibonacci.

Consider how the problem is solved: from top to bottom or bottom to top.

Practice

1. What is the main advantage of using Dynamic Programming (DP) to calculate Fibonacci numbers compared to a simple recursive approach?

easy

A. It avoids repeated calculations by storing intermediate results.

B. It uses less memory by not storing any results.

C. It calculates Fibonacci numbers using only addition without recursion.

D. It uses randomization to speed up calculations.

Solution

1. Step 1: Understand recursive Fibonacci inefficiency

   Simple recursion recalculates the same Fibonacci numbers many times, causing exponential time complexity.

2. Step 2: How DP improves calculation

   DP stores previously calculated Fibonacci numbers in a table (memoization or tabulation), avoiding repeated work.

3. Final Answer:

   It avoids repeated calculations by storing intermediate results. -> Option A

4. Quick Check:

   DP stores results to avoid repeats [OK]

Hint: DP saves results to avoid repeating work [OK]

Common Mistakes:

• Thinking DP uses less memory than recursion
• Believing DP removes addition operations
• Confusing DP with randomization

2. Which of the following Python code snippets correctly initializes a list to store Fibonacci numbers for DP with n = 5?

easy

A. fib = [0] * 5

B. fib = [0] * 6

C. fib = [1] * 5

D. fib = []

Solution

1. Step 1: Determine list size for Fibonacci DP

   For n=5, we need indices 0 to 5 inclusive, so list size must be 6.

2. Step 2: Check initialization correctness

   fib = [0] * 6 creates a list of six zeros, ready to store fib[0] to fib[5].

3. Final Answer:

   fib = [0] * 6 -> Option B

4. Quick Check:

   List size = n+1 for fib numbers [OK]

Hint: List size must be n+1 for fib up to n [OK]

Common Mistakes:

• Using list size equal to n instead of n+1
• Initializing with ones instead of zeros
• Leaving list empty without size

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

def fib_dp(n):
    fib = [0] * (n+1)
    fib[0], fib[1] = 0, 1
    for i in range(2, n+1):
        fib[i] = fib[i-1] + fib[i-2]
    return fib[n]

print(fib_dp(6))

medium

A. 5

B. 13

C. 8

D. 21

Solution

1. Step 1: Trace Fibonacci values up to n=6

   fib[0]=0, fib[1]=1; then fib[2]=1, fib[3]=2, fib[4]=3, fib[5]=5, fib[6]=8.

2. Step 2: Return fib[6]

   The function returns fib[6], which is 8.

3. Final Answer:

   8 -> Option C

4. Quick Check:

   fib(6) = 8 [OK]

Hint: Calculate fib step-by-step from base cases [OK]

Common Mistakes:

• Confusing fib(6) with fib(7)
• Starting fib from 1 instead of 0
• Off-by-one errors in loop range

4. Identify the error in this Fibonacci DP code and select the correct fix:

def fib_dp(n):
    fib = [0] * n
    fib[0], fib[1] = 0, 1
    for i in range(2, n+1):
        fib[i] = fib[i-1] + fib[i-2]
    return fib[n]

medium

A. Change for loop to range(1, n)

B. Change fib[0], fib[1] = 0, 1 to fib[1], fib[2] = 0, 1

C. Return fib[n-1] instead of fib[n]

D. Change fib = [0] * n to fib = [0] * (n+1)

Solution

1. Step 1: Check list size for indexing

   fib list size is n, but code accesses fib[n], which is out of range.

2. Step 2: Fix list size

   Changing fib = [0] * n to fib = [0] * (n+1) allows indexing up to fib[n].

3. Final Answer:

   Change fib = [0] * n to fib = [0] * (n+1) -> Option D

4. Quick Check:

   List size must cover fib[n] index [OK]

Hint: List size must be n+1 for fib[n] access [OK]

Common Mistakes:

• Not increasing list size causes IndexError
• Changing base cases incorrectly
• Altering loop range wrongly

5. You want to find the sum of the first n Fibonacci numbers efficiently using DP. Which modification to the standard Fibonacci DP code below will correctly compute this sum?

def fib_sum(n):
    fib = [0] * (n+1)
    fib[0], fib[1] = 0, 1
    for i in range(2, n+1):
        fib[i] = fib[i-1] + fib[i-2]
    # What to add here to get sum of fib[0] to fib[n]?
    return ???

hard

A. return fib[n+2] - 1

B. return fib[n] * 2

C. return fib[n] + fib[n-1]

D. return sum(fib)

Solution

1. Step 1: Understand sum of Fibonacci numbers

   The sum of first n Fibonacci numbers is fib[0] + fib[1] + ... + fib[n].

2. Step 2: Use known Fibonacci sum formula

   The sum of first n Fibonacci numbers equals fib[n+2] - 1.

3. Final Answer:

   return fib[n+2] - 1 -> Option A

4. Quick Check:

   Sum of fib numbers = fib[n+2] - 1 [OK]

Hint: Sum of first n fib numbers = fib[n+2] - 1 [OK]

Common Mistakes:

• Using fib[n]*2 which is incorrect
• Using sum(fib) which is inefficient
• Adding only last two fib numbers