Overlapping Subproblems and Optimal Substructure in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does Overlapping Subproblems mean in dynamic programming?

It means the problem can be broken into smaller subproblems which are solved multiple times. Instead of solving them again, we store their results to avoid repeated work.

beginner

Define Optimal Substructure in simple terms.

A problem has optimal substructure if the best solution can be made by combining the best solutions of its smaller parts.

beginner

Why is Overlapping Subproblems important for dynamic programming?

Because it allows us to save time by remembering answers to subproblems and reusing them, instead of solving the same subproblems again and again.

intermediate

Give an example of a problem that shows Optimal Substructure.

The shortest path problem: The shortest path from start to end includes shortest paths of smaller parts. So, solving smaller parts optimally helps solve the whole problem optimally.

intermediate

How do Overlapping Subproblems and Optimal Substructure work together in dynamic programming?

Optimal substructure lets us build the best solution from smaller best solutions. Overlapping subproblems let us reuse answers to these smaller problems efficiently by storing them.

Which of these best describes overlapping subproblems?

A Subproblems are all different

B Subproblems are solved multiple times

C Subproblems never repeat

D Subproblems are unrelated

Overlapping subproblems means the same smaller problems appear multiple times and can be reused.

What does optimal substructure allow us to do?

A Avoid solving subproblems

B Ignore smaller problems

C Solve problems randomly

D Build the best solution from best smaller solutions

Optimal substructure means the overall best solution depends on best solutions of smaller parts.

Which technique uses overlapping subproblems and optimal substructure?

A Dynamic Programming

B Greedy Algorithms

C Divide and Conquer

D Brute Force

Dynamic programming solves problems by reusing solutions to overlapping subproblems and using optimal substructure.

If a problem does NOT have overlapping subproblems, what is likely true?

A Dynamic programming is less useful

B Dynamic programming is perfect

C Optimal substructure is guaranteed

D Problem is unsolvable

Without overlapping subproblems, dynamic programming gains less benefit because subproblems are unique.

Which problem is a classic example of overlapping subproblems?

A Finding max in unsorted list

B Sorting an array

C Fibonacci sequence calculation

D Binary search

Fibonacci numbers require calculating the same smaller Fibonacci numbers multiple times, showing overlapping subproblems.

Explain in your own words what overlapping subproblems and optimal substructure mean and why they matter in dynamic programming.

Think about how breaking problems into smaller parts helps solve big problems efficiently.

Describe a real-life example or simple problem that shows both overlapping subproblems and optimal substructure.

Try the Fibonacci sequence or shortest path in a city.

Practice

1. Which of the following best describes the overlapping subproblems property in dynamic programming?

easy

A. The problem can be broken down into smaller subproblems that are reused multiple times.

B. The problem has a unique solution without repeating any subproblems.

C. The problem requires sorting before solving.

D. The problem can only be solved using recursion without memoization.

Solution

1. Step 1: Understand overlapping subproblems

   Overlapping subproblems means the same smaller problems appear multiple times during solving.

2. Step 2: Match definition to options

   The problem can be broken down into smaller subproblems that are reused multiple times. correctly states that subproblems are reused multiple times, which is the key idea.

3. Final Answer:

   The problem can be broken down into smaller subproblems that are reused multiple times. -> Option A

4. Quick Check:

   Overlapping subproblems = reuse of subproblems [OK]

Hint: Look for repeated smaller problems in the main problem [OK]

Common Mistakes:

• Confusing overlapping subproblems with unique subproblems
• Thinking sorting is required for overlapping subproblems
• Assuming recursion alone solves overlapping subproblems

2. Which of the following Python function definitions correctly uses memoization to solve overlapping subproblems?

easy

A. def fib(n): if n <= 1: return n else: return fib(n-1) + fib(n-2)

B. def fib(n): return n * fib(n-1)

C. def fib(n): for i in range(n): print(i)

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

Solution

1. Step 1: Identify memoization usage

   Memoization stores results of subproblems to avoid repeated work, usually with a dictionary.

2. Step 2: Check each option

   def fib(n, memo={}): if n in memo: return memo[n] if n <= 1: memo[n] = n else: memo[n] = fib(n-1, memo) + fib(n-2, memo) return memo[n] uses a dictionary 'memo' to save and reuse results, correctly implementing memoization.

3. Final Answer:

   def fib(n, memo={}): if n in memo: return memo[n] if n <= 1: memo[n] = n else: memo[n] = fib(n-1, memo) + fib(n-2, memo) return memo[n] -> Option D

4. Quick Check:

   Memoization = caching results [OK]

Hint: Look for a cache (dictionary) storing computed results [OK]

Common Mistakes:

• Missing memo dictionary parameter
• Not returning cached results
• Using loops without caching results

3. What is the output of the following code?

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

print(fib(5))

medium

A. 13

B. 8

C. 5

D. 3

Solution

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

   fib(5) calls fib(4) and fib(3), which further call smaller fib values, caching results to avoid repeats.

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 C

4. Quick Check:

   Fibonacci(5) = 5 [OK]

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

Common Mistakes:

• Confusing fib(5) with fib(6)
• Ignoring memoization effect
• Miscounting base cases

4. The following code attempts to use memoization for Fibonacci numbers but has a bug. What is the error?

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

print(fib(4))

medium

A. Missing memo argument in recursive calls causes infinite recursion.

B. Base case is incorrect for n <= 1.

C. Memo dictionary is not initialized.

D. Return statement is missing.

Solution

1. Step 1: Check recursive calls

   Recursive calls fib(n-1) and fib(n-2) do not pass 'memo', so memo is empty each time.

2. Step 2: Understand effect of missing memo argument

   Without passing memo, caching fails and recursion repeats infinitely, causing a stack overflow.

3. Final Answer:

   Missing memo argument in recursive calls causes infinite recursion. -> Option A

4. Quick Check:

   Pass memo in recursive calls to fix [OK]

Hint: Always pass memo/cache in recursive calls [OK]

Common Mistakes:

• Forgetting to pass memo in recursive calls
• Assuming base case alone stops recursion
• Not initializing memo outside function

5. You want to find the minimum cost to reach the top of stairs where each step has a cost. You can climb 1 or 2 steps at a time. Which approach best uses optimal substructure and overlapping subproblems to solve this?

hard

A. Use recursion without caching to try all paths.

B. Use dynamic programming to store minimum cost for each step and build up solution.

C. Sort the costs and pick the smallest steps first.

D. Use a greedy approach to always pick the next step with minimum cost.

Solution

1. Step 1: Understand problem structure

   Minimum cost to reach step i depends on minimum cost to reach steps i-1 and i-2 plus cost at i.

2. Step 2: Apply dynamic programming

   Store minimum costs for each step to avoid recomputing (overlapping subproblems) and use previous results (optimal substructure).

3. Final Answer:

   Use dynamic programming to store minimum cost for each step and build up solution. -> Option B

4. Quick Check:

   DP uses optimal substructure + overlapping subproblems [OK]

Hint: Build solution step-by-step storing results [OK]

Common Mistakes:

• Using recursion without memoization causing slow solution
• Trying greedy approach which may fail
• Sorting costs which is irrelevant