Overlapping Subproblems and Optimal Substructure in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Fibonacci with Memoization

What is the output of the following C++ code that calculates Fibonacci numbers using memoization?

DSA C++

#include <iostream>
#include <vector>

int fib(int n, std::vector<int>& memo) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
    return memo[n];
}

int main() {
    int n = 5;
    std::vector<int> memo(n + 1, -1);
    std::cout << fib(n, memo) << std::endl;
    return 0;
}

A 5

B 8

C 3

D 13

💡 Hint

Remember that Fibonacci sequence starts with 0, 1, 1, 2, 3, 5...

The function calculates the 5th Fibonacci number (0-based index), which is 5.

🧠 Conceptual

intermediate

Identifying Overlapping Subproblems

Which of the following problems best demonstrates the concept of overlapping subproblems?

A Sorting an array using quicksort

B Calculating factorial of a number using recursion

C Finding the nth Fibonacci number using recursion without memoization

D Searching for an element in a binary search tree

💡 Hint

Overlapping subproblems means the same smaller problems are solved multiple times.

Fibonacci recursion without memoization recalculates the same Fibonacci numbers multiple times, showing overlapping subproblems.

🔧 Debug

advanced

Debugging Memoization Implementation

What error does the following code produce when trying to compute the Fibonacci number with memoization?

DSA C++

#include <iostream>
#include <vector>

int fib(int n, std::vector<int> memo) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
    return memo[n];
}

int main() {
    int n = 4;
    std::vector<int> memo(n + 1, -1);
    std::cout << fib(n, memo) << std::endl;
    return 0;
}

A Output: 3

B Runtime error: segmentation fault

C Output: 0

D Compilation error due to missing & in function parameter

💡 Hint

Check how the memo vector is passed to the function.

The memo vector is passed by value, so updates inside fib do not persist. The function should take memo by reference to avoid this issue.

❓ Predict Output

advanced

Output of Dynamic Programming Table for Coin Change

What is the output of the following C++ code that calculates the number of ways to make change for amount 5 using coins {1, 2, 5}?

DSA C++

#include <iostream>
#include <vector>

int countWays(int amount, const std::vector<int>& coins) {
    std::vector<int> dp(amount + 1, 0);
    dp[0] = 1;
    for (int coin : coins) {
        for (int x = coin; x <= amount; ++x) {
            dp[x] += dp[x - coin];
        }
    }
    return dp[amount];
}

int main() {
    std::vector<int> coins = {1, 2, 5};
    int amount = 5;
    std::cout << countWays(amount, coins) << std::endl;
    return 0;
}

A 3

B 4

C 5

D 2

💡 Hint

Think about all combinations of coins that sum to 5.

The ways are: {1,1,1,1,1}, {1,1,1,2}, {1,2,2}, {5}, total 4 ways.

🧠 Conceptual

expert

Optimal Substructure in Shortest Path Problem

Which statement best describes the optimal substructure property in the shortest path problem?

A The shortest path between two nodes contains the shortest paths between intermediate nodes.

B The shortest path is always unique and does not depend on subpaths.

C The shortest path can be found by checking all possible paths without reusing subpaths.

D The shortest path ignores the weights of edges between nodes.

💡 Hint

Optimal substructure means optimal solutions contain optimal subsolutions.

In shortest path problems, any subpath of a shortest path is itself a shortest path, showing optimal substructure.

Practice

1. Which of the following best describes the property of Overlapping Subproblems in dynamic programming?

easy

A. The problem can be broken down into smaller subproblems which are solved 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 the solution process.

2. Step 2: Match the definition to options

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

3. Final Answer:

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

4. Quick Check:

   Overlapping Subproblems = Smaller repeated subproblems [OK]

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

Common Mistakes:

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

2. Which of the following C++ function signatures correctly represents a memoized Fibonacci function using dynamic programming?

easy

A. void fib(int n);

B. int fib();

C. int fib(int n);

D. int fib(int n, int memo[]);

Solution

1. Step 1: Identify memoization parameters

   Memoization requires an extra data structure (like an array) to store results of subproblems.

2. Step 2: Check function signatures

   int fib(int n, int memo[]); includes an array parameter to store memoized results, which is necessary for memoization.

3. Final Answer:

   int fib(int n, int memo[]); -> Option D

4. Quick Check:

   Memoization needs storage parameter [OK]

Hint: Memoized functions need extra storage parameter [OK]

Common Mistakes:

• Ignoring the memo array parameter
• Using void return type for Fibonacci
• Not passing any parameters for recursion

3. What is the output of the following C++ code snippet?

int fib(int n, int memo[]) {
  if (n <= 1) return n;
  if (memo[n] != -1) return memo[n];
  memo[n] = fib(n-1, memo) + fib(n-2, memo);
  return memo[n];
}

int main() {
  int n = 5;
  int memo[6];
  for(int i = 0; i <= n; i++) memo[i] = -1;
  std::cout << fib(n, memo);
  return 0;
}

medium

A. 13

B. 8

C. 3

D. 5

Solution

1. Step 1: Understand Fibonacci calculation

   fib(5) = fib(4) + fib(3). Using memoization, fib(5) = 8.

2. Step 2: Trace the code execution

   Memo array initialized with -1, so recursive calls compute and store values. fib(5) returns 8.

3. Final Answer:

   8 -> Option B

4. Quick Check:

   fib(5) = 8 [OK]

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

Common Mistakes:

• Confusing fib(5) with fib(6)
• Forgetting zero-based indexing
• Assuming memo array is not initialized

4. Identify the error in the following code snippet implementing memoized Fibonacci:

int fib(int n, int memo[]) {
  if (n == 0) return 0;
  if (n == 1) return 1;
  if (memo[n] != 0) return memo[n];
  memo[n] = fib(n-1, memo) + fib(n-2, memo);
  return memo[n];
}

medium

A. The function should return void instead of int.

B. Base cases should return -1 instead of 0 or 1.

C. Memo array should be initialized with -1, not 0.

D. The memo array size is not checked inside the function.

Solution

1. Step 1: Check memoization condition

   The code checks if memo[n] != 0 to decide if value is computed, but 0 is a valid Fibonacci value.

2. Step 2: Correct initialization for memo array

   Memo array should be initialized with a value like -1 to indicate uncomputed states, avoiding confusion with valid 0.

3. Final Answer:

   Memo array should be initialized with -1, not 0. -> Option C

4. Quick Check:

   Use -1 for uninitialized memo values [OK]

Hint: Initialize memo with -1 to distinguish computed from uncomputed [OK]

Common Mistakes:

• Using 0 as default memo value causing wrong cache hits
• Changing base case return values incorrectly
• Ignoring memo array size checks

5. Given the problem of finding the minimum cost path in a grid from top-left to bottom-right, which property justifies using dynamic programming to solve it efficiently?

hard

A. The problem has both overlapping subproblems and optimal substructure.

B. The problem has optimal substructure but no overlapping subproblems.

C. The problem has overlapping subproblems but no optimal substructure.

D. The problem has neither overlapping subproblems nor optimal substructure.

Solution

1. Step 1: Understand minimum cost path problem

   The problem breaks into smaller subproblems (paths to cells) that overlap and solutions combine optimally.

2. Step 2: Identify properties

   It has overlapping subproblems (same cells computed multiple times) and optimal substructure (optimal path uses optimal subpaths).

3. Final Answer:

   The problem has both overlapping subproblems and optimal substructure. -> Option A

4. Quick Check:

   Minimum cost path = Overlapping + Optimal substructure [OK]

Hint: Check if subproblems repeat and combine optimally [OK]

Common Mistakes:

• Thinking only one property applies
• Confusing optimal substructure with greedy choice
• Ignoring repeated subproblems in grid paths