Overlapping Subproblems and Optimal Substructure in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the nth Fibonacci number using recursion.

DSA C++

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

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition.

Forgetting the base case for n <= 1.

The Fibonacci number is the sum of the two previous Fibonacci numbers, so we add fib(n-1) and fib(n-2).

2fill in blank

medium

Complete the code to memoize the Fibonacci function using a vector.

DSA C++

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

Drag options to blanks, or click blank then click option'

A*

B-

C+

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong operators in the recursive sum.

Not storing the computed value in memo.

Memoization stores the sum of fib(n-1) and fib(n-2) to avoid repeated calculations.

3fill in blank

hard

Fix the error in the bottom-up Fibonacci implementation to correctly fill the dp array.

DSA C++

int fibDP(int n) {
    std::vector<int> dp(n + 1, 0);
    dp[0] = 0;
    dp[1] = 1;
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] [1] dp[i - 2];
    }
    return dp[n];
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition.

Incorrect loop bounds.

Each Fibonacci number is the sum of the two previous numbers in the dp array.

4fill in blank

hard

Complete the space-optimized dynamic programming implementation for the nth Fibonacci number.

DSA C++

int fibSpace(int n) {
    if (n <= 1) return n;
    int prev = 0;
    int curr = 1;
    for (int i = 2; i <= n; ++i) {
        int next = prev [1] curr;
        prev = curr;
        curr = next;
    }
    return curr;
}

Drag options to blanks, or click blank then click option'

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong operator instead of addition.

Incorrectly updating the prev and curr variables.

In space-optimized DP for Fibonacci, each subsequent value is the sum of the previous two values using constant extra space.

5fill in blank

hard

Complete the recurrence relation in the bottom-up 0/1 Knapsack DP implementation.

DSA C++

int knapsack(int W, std::vector<int>& wt, std::vector<int>& val, int n) {
    std::vector<std::vector<int>> dp(n + 1, std::vector<int>(W + 1, 0));
    for (int i = 1; i <= n; ++i) {
        for (int w = 1; w <= W; ++w) {
            if (wt[i - 1] <= w) {
                dp[i][w] = std::max(dp[i - 1][w], val[i - 1] [1] dp[i - 1][w - wt[i - 1]]);
            } else {
                dp[i][w] = dp[i - 1][w];
            }
        }
    }
    return dp[n][W];
}

Drag options to blanks, or click blank then click option'

A-

B/

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using min instead of max.

Wrong operator when including the item.

The optimal substructure chooses the maximum between skipping the item or taking it (value + subproblem with reduced weight).

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