Fibonacci Using DP in DSA Java

Mental Model

We remember past Fibonacci numbers so we don't repeat work. This saves time by building answers step-by-step.

Analogy: Imagine climbing stairs where you write down how many ways to reach each step so you don't count again later.

Fib array: [0, 1, _, _, _, _]
Index:     0  1  2  3  4  5

Dry Run Walkthrough

Input: Calculate Fibonacci number for n=5 using DP

Goal: Find the 5th Fibonacci number efficiently by storing previous results

Step 1: Initialize array with base cases fib[0]=0 and fib[1]=1

fib: [0, 1, _, _, _, _]

Why: We need starting points to build next Fibonacci numbers

Step 2: Calculate fib[2] = fib[1] + fib[0] = 1 + 0 = 1

fib: [0, 1, 1, _, _, _]

Why: Use stored values to find next Fibonacci number

Step 3: Calculate fib[3] = fib[2] + fib[1] = 1 + 1 = 2

fib: [0, 1, 1, 2, _, _]

Why: Build on previous results to avoid repeated work

Step 4: Calculate fib[4] = fib[3] + fib[2] = 2 + 1 = 3

fib: [0, 1, 1, 2, 3, _]

Why: Continue building sequence using stored values

Step 5: Calculate fib[5] = fib[4] + fib[3] = 3 + 2 = 5

fib: [0, 1, 1, 2, 3, 5]

Why: Final Fibonacci number for n=5 found efficiently

Result:

fib: [0, 1, 1, 2, 3, 5]
Answer: 5

Annotated Code

DSA Java

public class FibonacciDP {
    // Calculate nth Fibonacci number using DP
    public static int fib(int n) {
        if (n <= 1) return n; // base cases
        int[] fib = new int[n + 1];
        fib[0] = 0; // fib(0)
        fib[1] = 1; // fib(1)
        for (int i = 2; i <= n; i++) {
            fib[i] = fib[i - 1] + fib[i - 2]; // build fib[i] from previous two
        }
        return fib[n];
    }

    public static void main(String[] args) {
        int n = 5;
        int result = fib(n);
        System.out.println("Fibonacci number for n=" + n + " is " + result);
    }
}

if (n <= 1) return n; // base cases

Handle smallest Fibonacci numbers directly

fib[0] = 0; // fib(0)

Set first Fibonacci number

fib[1] = 1; // fib(1)

Set second Fibonacci number

for (int i = 2; i <= n; i++) {

Iterate from 2 to n to fill Fibonacci array

fib[i] = fib[i - 1] + fib[i - 2]; // build fib[i] from previous two

Calculate current Fibonacci number using previous two

return fib[n];

Return the nth Fibonacci number

Output

Fibonacci number for n=5 is 5

Complexity Analysis

Time: O(n) because we calculate each Fibonacci number once from 2 to n

Space: O(n) because we store all Fibonacci numbers up to n in an array

vs Alternative: Compared to naive recursion which is O(2^n), DP is much faster by avoiding repeated calculations

Edge Cases

n = 0

Returns 0 immediately as base case

DSA Java

if (n <= 1) return n; // base cases

n = 1

Returns 1 immediately as base case

DSA Java

if (n <= 1) return n; // base cases

n is large (e.g., 50)

Calculates efficiently without stack overflow using iteration

DSA Java

for (int i = 2; i <= n; i++) {

When to Use This Pattern

When a problem asks for Fibonacci or similar sequences, use DP to store previous results and avoid repeated work for fast calculation.

Common Mistakes

Mistake: Using naive recursion without memoization causing exponential time
Fix: Use an array to store computed Fibonacci numbers and build up iteratively

Mistake: Forgetting base cases fib(0) and fib(1), causing wrong results or errors
Fix: Explicitly handle n=0 and n=1 before loop

Summary

Calculates Fibonacci numbers efficiently by storing previous results in an array.

Use when you need fast Fibonacci calculation without repeated work.

Remember: build each Fibonacci number from the two before using stored values.

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 uses less memory by not storing any intermediate results.

B. It avoids repeated calculations by storing results of subproblems.

C. It calculates Fibonacci numbers using a closed-form formula.

D. It uses randomization to speed up the calculation.

Solution

1. Step 1: Understand recursive Fibonacci drawbacks

   Simple recursion recalculates the same Fibonacci numbers many times, causing inefficiency.

2. Step 2: How DP improves calculation

   DP stores results of smaller Fibonacci numbers to reuse them, avoiding repeated work.

3. Final Answer:

   It avoids repeated calculations by storing results of subproblems. -> Option B

4. Quick Check:

   DP stores subproblem results = avoids repeats [OK]

Hint: DP saves previous results to avoid repeated work [OK]

Common Mistakes:

• Thinking DP uses less memory than recursion
• Confusing DP with closed-form formulas
• Believing DP uses randomization

2. Which of the following Java code snippets correctly initializes the DP array for Fibonacci calculation of size n?

easy

A. int[] dp = new int[n]; dp[0] = 0; dp[1] = 1;

B. int[] dp = new int[n]; dp[0] = 1; dp[1] = 1;

C. int[] dp = new int[n-1]; dp[0] = 0; dp[1] = 1;

D. int[] dp = new int[n+1]; dp[0] = 0; dp[1] = 1;

Solution

1. Step 1: Determine array size for Fibonacci DP

   To store Fibonacci numbers up to n, array size must be n+1 to include index n.

2. Step 2: Check base cases initialization

   Fibonacci starts with dp[0] = 0 and dp[1] = 1, so these must be set correctly.

3. Final Answer:

   int[] dp = new int[n+1]; dp[0] = 0; dp[1] = 1; -> Option D

4. Quick Check:

   Array size n+1 with dp[0]=0, dp[1]=1 = correct initialization [OK]

Hint: Array size must be n+1 to hold Fibonacci up to n [OK]

Common Mistakes:

• Using array size n instead of n+1
• Initializing dp[0] as 1 instead of 0
• Using array size n-1 causing index errors

3. What is the output of the following Java code snippet?

int n = 5;
int[] dp = new int[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
    dp[i] = dp[i-1] + dp[i-2];
}
System.out.println(dp[n]);

medium

A. 3

B. 8

C. 5

D. 13

Solution

1. Step 1: Calculate Fibonacci values up to n=5

   dp[0]=0, dp[1]=1 Then dp[2]=1, dp[3]=2, dp[4]=3, dp[5]=5

2. Step 2: Output dp[5]

   The value at dp[5] is 5, so the output is 5.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   Fibonacci(5) = 5 [OK]

Hint: Fibonacci(5) is 5 by definition [OK]

Common Mistakes:

• Confusing index with Fibonacci value
• Calculating dp[5] as 8 (Fibonacci(6))
• Off-by-one errors in loop

4. Identify the error in the following Java code for Fibonacci using DP and select the correct fix:

int n = 6;
int[] dp = new int[n];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
    dp[i] = dp[i-1] + dp[i-2];
}
System.out.println(dp[n]);

medium

A. Change array size to n+1 to avoid index out of bounds error.

B. Initialize dp[2] = 1 before the loop.

C. Change loop condition to i < n instead of i <= n.

D. Remove dp[0] initialization.

Solution

1. Step 1: Analyze array size and loop bounds

   Array dp has size n (6), but loop runs i from 2 to 6 inclusive, accessing dp[6] which is out of bounds.

2. Step 2: Fix array size to n+1

   Increasing array size to n+1 (7) allows dp[6] access without error.

3. Final Answer:

   Change array size to n+1 to avoid index out of bounds error. -> Option A

4. Quick Check:

   Array size n+1 fixes index error [OK]

Hint: Array size must cover max index used in loop [OK]

Common Mistakes:

• Ignoring index out of bounds exception
• Changing loop condition without fixing array size
• Unnecessary initialization of dp[2]

5. You want to calculate the 10th Fibonacci number using DP but with space optimization to use only two variables instead of an array. Which code snippet correctly implements this?

hard

A. int a = 0, b = 1, c = 0; for (int i = 2; i <= 10; i++) { c = a + b; a = b; b = c; } System.out.println(c);

B. int a = 0, b = 1; for (int i = 2; i <= 10; i++) { a = a + b; b = a; } System.out.println(b);

C. int a = 0, b = 1; for (int i = 2; i < 10; i++) { int c = a + b; a = b; b = c; } System.out.println(b);

D. int a = 1, b = 1; for (int i = 2; i <= 10; i++) { int c = a + b; a = b; b = c; } System.out.println(b);

Solution

1. Step 1: Understand space optimization for Fibonacci

   We only need last two Fibonacci numbers to calculate the next, so two variables plus one temp variable suffice.

2. Step 2: Check loop and initialization correctness

   Start with a=0, b=1 (F0 and F1), loop from 2 to 10 inclusive, update c = a+b, then shift a=b, b=c.

3. Step 3: Verify output

   After loop, c holds Fibonacci(10) = 55, which is printed.

4. Final Answer:

   int a = 0, b = 1, c = 0; for (int i = 2; i <= 10; i++) { c = a + b; a = b; b = c; } System.out.println(c); -> Option A

5. Quick Check:

   Two vars + temp, correct loop = Fibonacci(10) [OK]

Hint: Use two vars and update in loop to save space [OK]

Common Mistakes:

• Incorrect loop bounds causing off-by-one
• Wrong initial values for a and b
• Not updating variables in correct order