Why Dynamic Programming and When Recursion Alone Fails in DSA Go - Quick Recap

Recall & Review

beginner

What is the main problem with using plain recursion for some problems?

Plain recursion can repeat the same calculations many times, which wastes time and makes the program slow.

beginner

What does Dynamic Programming (DP) do to improve recursion?

DP saves the results of subproblems so they don’t have to be calculated again, making the program faster.

intermediate

What is 'overlapping subproblems' in the context of recursion?

It means the same smaller problems are solved multiple times during recursion.

beginner

Why is recursion alone not efficient for problems like Fibonacci numbers?

Because it recalculates the same Fibonacci numbers many times, causing exponential time complexity.

beginner

How does memoization help in recursion?

Memoization stores answers to subproblems in a table so that when the same problem appears again, the answer is reused instead of recalculated.

What is the main reason to use Dynamic Programming instead of plain recursion?

A To avoid repeating calculations of the same subproblems

B To make the code shorter

C To use more memory without speed benefit

D To avoid using loops

Dynamic Programming avoids repeating calculations by saving results of subproblems.

Which problem characteristic suggests that Dynamic Programming can help?

A Only one big problem with no smaller parts

B No repeated subproblems

C Overlapping subproblems

D Problems that do not use recursion

Overlapping subproblems mean the same smaller problems appear multiple times, which DP can optimize.

What is memoization in Dynamic Programming?

A Saving results of subproblems to reuse later

B Writing code without recursion

C Using loops instead of recursion

D Ignoring subproblems

Memoization stores answers to subproblems to avoid recalculating them.

Why does plain recursion for Fibonacci numbers become slow?

A It uses too much memory

B It only calculates the first number

C It does not use recursion properly

D It recalculates the same Fibonacci numbers many times

Plain recursion repeats calculations for the same Fibonacci numbers, causing slow performance.

Which of these is NOT a benefit of Dynamic Programming?

A Using extra memory to store results

B Always using less memory than recursion

C Simplifying problems by breaking them into subproblems

D Faster execution by avoiding repeated work

Dynamic Programming often uses more memory to store results, so it does not always use less memory than recursion.

Explain why recursion alone can be inefficient and how Dynamic Programming fixes this problem.

Think about how many times the same small problem is solved.

Describe the concept of overlapping subproblems and why it matters for choosing Dynamic Programming.

Focus on repeated work in recursion.

Practice

1. Why do we use dynamic programming instead of plain recursion for some problems?

easy

A. Because dynamic programming uses less memory than recursion

B. Because dynamic programming stores results to avoid repeated work

C. Because recursion cannot solve problems with multiple choices

D. Because recursion is always slower than loops

Solution

1. Step 1: Understand recursion's limitation

   Recursion often recalculates the same subproblems multiple times, causing inefficiency.

2. Step 2: Role of dynamic programming

   Dynamic programming saves results of subproblems (memoization) to avoid repeated calculations.

3. Final Answer:

   Because dynamic programming stores results to avoid repeated work -> Option B

4. Quick Check:

   Memoization avoids repeated work = D [OK]

Hint: Dynamic programming saves repeated results to speed up recursion [OK]

Common Mistakes:

• Thinking recursion is always slower than loops
• Believing recursion can't handle multiple choices
• Confusing memory use between recursion and DP

2. Which Go syntax correctly declares a recursive function to compute Fibonacci numbers?

easy

A. func fib(n int) int { if n <= 1 { return n } return fib(n-1) + fib(n-2) }

B. func fib(n int) { if n <= 1 { return n } return fib(n-1) + fib(n-2) }

C. func fib(n int) int { if n < 0 { return 0 } return fib(n-1) + fib(n-2) }

D. func fib(n int) int { if n == 0 { return 0 } else { return fib(n-1) + fib(n-2) } }

Solution

1. Step 1: Check function signature and return type

   func fib(n int) int { if n <= 1 { return n } return fib(n-1) + fib(n-2) } correctly declares return type int and returns int values.

2. Step 2: Verify base cases and recursion

   func fib(n int) int { if n <= 1 { return n } return fib(n-1) + fib(n-2) } uses base case n <= 1 returning n, and recursive calls fib(n-1)+fib(n-2), which is correct.

3. Final Answer:

   func fib(n int) int { if n <= 1 { return n } return fib(n-1) + fib(n-2) } -> Option A

4. Quick Check:

   Correct signature and base case = B [OK]

Hint: Check function return type and base cases carefully [OK]

Common Mistakes:

• Missing return type in function signature
• Incorrect base case conditions
• Returning void instead of int

3. What is the output of this Go code snippet?

import "fmt"

func fib(n int) int {
    if n <= 1 {
        return n
    }
    return fib(n-1) + fib(n-2)
}

func main() {
    fmt.Println(fib(5))
}

medium

A. 13

B. 8

C. 5

D. Error

Solution

1. Step 1: Trace fib(5) calls

   fib(5) = fib(4) + fib(3), fib(4) = fib(3) + fib(2), fib(3) = fib(2) + fib(1), etc.

2. Step 2: Calculate values bottom-up

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

3. Final Answer:

   5 -> Option C

4. Quick Check:

   Fibonacci(5) = 5 [OK]

Hint: Recall Fibonacci sequence: 0,1,1,2,3,5... [OK]

Common Mistakes:

• Confusing fib(5) with fib(6)
• Off-by-one errors in base cases
• Assuming output is sum of first 5 numbers

4. Identify the bug in this recursive Fibonacci function and choose the fix:

func fib(n int) int {
    if n == 0 {
        return 0
    } else if n == 1 {
        return 1
    }
    return fib(n-1) + fib(n-3)
}

medium

A. Change return type to float64

B. Change base case n == 0 to n <= 0

C. Add memoization to store results

D. Change fib(n-3) to fib(n-2) in the return statement

Solution

1. Step 1: Analyze recursive calls

   Function calls fib(n-1) + fib(n-3), but Fibonacci requires fib(n-1) + fib(n-2).

2. Step 2: Correct the recursive call

   Changing fib(n-3) to fib(n-2) fixes the logic to standard Fibonacci recursion.

3. Final Answer:

   Change fib(n-3) to fib(n-2) in the return statement -> Option D

4. Quick Check:

   Correct recursion calls = A [OK]

Hint: Fibonacci sums fib(n-1) and fib(n-2) only [OK]

Common Mistakes:

• Using wrong recursive indices
• Ignoring base cases
• Adding memoization without fixing recursion

5. You want to compute the nth Fibonacci number efficiently in Go. Which approach best avoids the exponential time of plain recursion?

hard

A. Use dynamic programming with memoization to store intermediate results

B. Use a tail-recursive version of Fibonacci

C. Use recursion with a global variable to count calls

D. Use recursion with multiple goroutines to parallelize calls

Solution

1. Step 1: Understand recursion inefficiency

   Plain recursion recalculates subproblems exponentially many times, causing slow performance.

2. Step 2: Compare approaches to optimize

   Memoization stores results to avoid repeated work, reducing time to linear - classic DP approach.

3. Step 3: Evaluate other options

   Global variable counting calls doesn't improve speed. Parallel recursion adds overhead and complexity without guaranteed speedup.

4. Final Answer:

   Use dynamic programming with memoization to store intermediate results -> Option A

5. Quick Check:

   Memoization avoids repeated work = C [OK]

Hint: Memoize results to avoid repeated recursion calls [OK]

Common Mistakes:

• Thinking parallel recursion always speeds up
• Using global counters instead of caching
• Thinking tail recursion avoids exponential time